* @widget: The GtkWidget whose properties and features are exported via this
* accessible instance
*/
-struct _GtkAccessiblePriv
+struct _GtkAccessiblePrivate
{
GtkWidget *widget;
};
{
accesible->priv = G_TYPE_INSTANCE_GET_PRIVATE (accesible,
GTK_TYPE_ACCESSIBLE,
- GtkAccessiblePriv);
+ GtkAccessiblePrivate);
}
static void
{
klass->connect_widget_destroyed = gtk_accessible_real_connect_widget_destroyed;
- g_type_class_add_private (klass, sizeof (GtkAccessiblePriv));
+ g_type_class_add_private (klass, sizeof (GtkAccessiblePrivate));
}
/**
static void
gtk_accessible_real_connect_widget_destroyed (GtkAccessible *accessible)
{
- GtkAccessiblePriv *priv = accessible->priv;
+ GtkAccessiblePrivate *priv = accessible->priv;
if (priv->widget)
{
#define GTK_ACCESSIBLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCESSIBLE, GtkAccessibleClass))
typedef struct _GtkAccessible GtkAccessible;
-typedef struct _GtkAccessiblePriv GtkAccessiblePriv;
+typedef struct _GtkAccessiblePrivate GtkAccessiblePrivate;
typedef struct _GtkAccessibleClass GtkAccessibleClass;
/*
AtkObject parent;
/*< private >*/
- GtkAccessiblePriv *priv;
+ GtkAccessiblePrivate *priv;
};
struct _GtkAccessibleClass
#include "gtkintl.h"
-struct _GtkAlignmentPriv
+struct _GtkAlignmentPrivate
{
gfloat xalign;
gfloat yalign;
0,
GTK_PARAM_READWRITE));
- g_type_class_add_private (gobject_class, sizeof (GtkAlignmentPriv));
+ g_type_class_add_private (gobject_class, sizeof (GtkAlignmentPrivate));
}
static void
gtk_alignment_init (GtkAlignment *alignment)
{
- GtkAlignmentPriv *priv;
+ GtkAlignmentPrivate *priv;
alignment->priv = G_TYPE_INSTANCE_GET_PRIVATE (alignment,
GTK_TYPE_ALIGNMENT,
- GtkAlignmentPriv);
+ GtkAlignmentPrivate);
priv = alignment->priv;
gtk_widget_set_has_window (GTK_WIDGET (alignment), FALSE);
gfloat yscale)
{
GtkAlignment *alignment;
- GtkAlignmentPriv *priv;
+ GtkAlignmentPrivate *priv;
alignment = g_object_new (GTK_TYPE_ALIGNMENT, NULL);
GParamSpec *pspec)
{
GtkAlignment *alignment = GTK_ALIGNMENT (object);
- GtkAlignmentPriv *priv = alignment->priv;
+ GtkAlignmentPrivate *priv = alignment->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkAlignment *alignment = GTK_ALIGNMENT (object);
- GtkAlignmentPriv *priv = alignment->priv;
+ GtkAlignmentPrivate *priv = alignment->priv;
switch (prop_id)
{
gfloat xscale,
gfloat yscale)
{
- GtkAlignmentPriv *priv;
+ GtkAlignmentPrivate *priv;
GtkWidget *child;
g_return_if_fail (GTK_IS_ALIGNMENT (alignment));
GtkAllocation *allocation)
{
GtkAlignment *alignment = GTK_ALIGNMENT (widget);
- GtkAlignmentPriv *priv = alignment->priv;
+ GtkAlignmentPrivate *priv = alignment->priv;
GtkBin *bin;
GtkAllocation child_allocation;
GtkWidget *bin_child;
gint *natural_size)
{
GtkAlignment *alignment = GTK_ALIGNMENT (widget);
- GtkAlignmentPriv *priv = alignment->priv;
+ GtkAlignmentPrivate *priv = alignment->priv;
GtkWidget *child;
guint minimum, natural;
guint padding_left,
guint padding_right)
{
- GtkAlignmentPriv *priv;
+ GtkAlignmentPrivate *priv;
GtkWidget *child;
g_return_if_fail (GTK_IS_ALIGNMENT (alignment));
guint *padding_left,
guint *padding_right)
{
- GtkAlignmentPriv *priv;
+ GtkAlignmentPrivate *priv;
g_return_if_fail (GTK_IS_ALIGNMENT (alignment));
#define GTK_ALIGNMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ALIGNMENT, GtkAlignmentClass))
-typedef struct _GtkAlignment GtkAlignment;
-typedef struct _GtkAlignmentPriv GtkAlignmentPriv;
-typedef struct _GtkAlignmentClass GtkAlignmentClass;
+typedef struct _GtkAlignment GtkAlignment;
+typedef struct _GtkAlignmentPrivate GtkAlignmentPrivate;
+typedef struct _GtkAlignmentClass GtkAlignmentClass;
struct _GtkAlignment
{
GtkBin bin;
/* <private> */
- GtkAlignmentPriv *priv;
+ GtkAlignmentPrivate *priv;
};
struct _GtkAlignmentClass
#define MIN_ARROW_SIZE 15
-struct _GtkArrowPriv
+struct _GtkArrowPrivate
{
gint16 arrow_type;
gint16 shadow_type;
0.0, 1.0, 0.7,
GTK_PARAM_READABLE));
- g_type_class_add_private (class, sizeof (GtkArrowPriv));
+ g_type_class_add_private (class, sizeof (GtkArrowPrivate));
}
static void
GParamSpec *pspec)
{
GtkArrow *arrow = GTK_ARROW (object);
- GtkArrowPriv *priv = arrow->priv;
+ GtkArrowPrivate *priv = arrow->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkArrow *arrow = GTK_ARROW (object);
- GtkArrowPriv *priv = arrow->priv;
+ GtkArrowPrivate *priv = arrow->priv;
switch (prop_id)
{
static void
gtk_arrow_init (GtkArrow *arrow)
{
- GtkArrowPriv *priv;
+ GtkArrowPrivate *priv;
gint xpad, ypad;
arrow->priv = G_TYPE_INSTANCE_GET_PRIVATE (arrow,
GTK_TYPE_ARROW,
- GtkArrowPriv);
+ GtkArrowPrivate);
priv = arrow->priv;
gtk_widget_set_has_window (GTK_WIDGET (arrow), FALSE);
gtk_arrow_new (GtkArrowType arrow_type,
GtkShadowType shadow_type)
{
- GtkArrowPriv *priv;
+ GtkArrowPrivate *priv;
GtkArrow *arrow;
arrow = g_object_new (GTK_TYPE_ARROW, NULL);
GtkArrowType arrow_type,
GtkShadowType shadow_type)
{
- GtkArrowPriv *priv;
+ GtkArrowPrivate *priv;
GtkWidget *widget;
g_return_if_fail (GTK_IS_ARROW (arrow));
if (gtk_widget_is_drawable (widget))
{
GtkArrow *arrow = GTK_ARROW (widget);
- GtkArrowPriv *priv = arrow->priv;
+ GtkArrowPrivate *priv = arrow->priv;
GtkMisc *misc = GTK_MISC (widget);
GtkShadowType shadow_type;
gint width, height;
#define GTK_IS_ARROW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ARROW))
#define GTK_ARROW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ARROW, GtkArrowClass))
-typedef struct _GtkArrow GtkArrow;
-typedef struct _GtkArrowPriv GtkArrowPriv;
-typedef struct _GtkArrowClass GtkArrowClass;
+typedef struct _GtkArrow GtkArrow;
+typedef struct _GtkArrowPrivate GtkArrowPrivate;
+typedef struct _GtkArrowClass GtkArrowClass;
struct _GtkArrow
{
GtkMisc misc;
/*< private >*/
- GtkArrowPriv *priv;
+ GtkArrowPrivate *priv;
};
struct _GtkArrowClass
-struct _GtkAspectFramePriv
+struct _GtkAspectFramePrivate
{
GtkAllocation center_allocation;
TRUE,
GTK_PARAM_READWRITE));
- g_type_class_add_private (class, sizeof (GtkAspectFramePriv));
+ g_type_class_add_private (class, sizeof (GtkAspectFramePrivate));
}
static void
gtk_aspect_frame_init (GtkAspectFrame *aspect_frame)
{
- GtkAspectFramePriv *priv;
+ GtkAspectFramePrivate *priv;
aspect_frame->priv = G_TYPE_INSTANCE_GET_PRIVATE (aspect_frame,
GTK_TYPE_ASPECT_FRAME,
- GtkAspectFramePriv);
+ GtkAspectFramePrivate);
priv = aspect_frame->priv;
priv->xalign = 0.5;
GParamSpec *pspec)
{
GtkAspectFrame *aspect_frame = GTK_ASPECT_FRAME (object);
- GtkAspectFramePriv *priv = aspect_frame->priv;
+ GtkAspectFramePrivate *priv = aspect_frame->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkAspectFrame *aspect_frame = GTK_ASPECT_FRAME (object);
- GtkAspectFramePriv *priv = aspect_frame->priv;
+ GtkAspectFramePrivate *priv = aspect_frame->priv;
switch (prop_id)
{
gboolean obey_child)
{
GtkAspectFrame *aspect_frame;
- GtkAspectFramePriv *priv;
+ GtkAspectFramePrivate *priv;
aspect_frame = g_object_new (GTK_TYPE_ASPECT_FRAME, NULL);
gfloat ratio,
gboolean obey_child)
{
- GtkAspectFramePriv *priv;
+ GtkAspectFramePrivate *priv;
g_return_if_fail (GTK_IS_ASPECT_FRAME (aspect_frame));
GtkAllocation *child_allocation)
{
GtkAspectFrame *aspect_frame = GTK_ASPECT_FRAME (frame);
- GtkAspectFramePriv *priv = aspect_frame->priv;
+ GtkAspectFramePrivate *priv = aspect_frame->priv;
GtkBin *bin = GTK_BIN (frame);
GtkWidget *child;
gdouble ratio;
#define GTK_IS_ASPECT_FRAME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ASPECT_FRAME))
#define GTK_ASPECT_FRAME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ASPECT_FRAME, GtkAspectFrameClass))
-typedef struct _GtkAspectFrame GtkAspectFrame;
-typedef struct _GtkAspectFramePriv GtkAspectFramePriv;
-typedef struct _GtkAspectFrameClass GtkAspectFrameClass;
+typedef struct _GtkAspectFrame GtkAspectFrame;
+typedef struct _GtkAspectFramePrivate GtkAspectFramePrivate;
+typedef struct _GtkAspectFrameClass GtkAspectFrameClass;
struct _GtkAspectFrame
{
GtkFrame frame;
/*< private >*/
- GtkAspectFramePriv *priv;
+ GtkAspectFramePrivate *priv;
};
struct _GtkAspectFrameClass
#include "gtkintl.h"
-struct _GtkButtonBoxPriv
+struct _GtkButtonBoxPrivate
{
GtkButtonBoxStyle layout_style;
};
FALSE,
GTK_PARAM_READWRITE));
- g_type_class_add_private (class, sizeof (GtkButtonBoxPriv));
+ g_type_class_add_private (class, sizeof (GtkButtonBoxPrivate));
}
static void
gtk_button_box_init (GtkButtonBox *button_box)
{
- GtkButtonBoxPriv *priv;
+ GtkButtonBoxPrivate *priv;
button_box->priv = G_TYPE_INSTANCE_GET_PRIVATE (button_box,
GTK_TYPE_BUTTON_BOX,
- GtkButtonBoxPriv);
+ GtkButtonBoxPrivate);
priv = button_box->priv;
gtk_box_set_spacing (GTK_BOX (button_box), 0);
GValue *value,
GParamSpec *pspec)
{
- GtkButtonBoxPriv *priv = GTK_BUTTON_BOX (object)->priv;
+ GtkButtonBoxPrivate *priv = GTK_BUTTON_BOX (object)->priv;
switch (prop_id)
{
gtk_button_box_set_layout (GtkButtonBox *widget,
GtkButtonBoxStyle layout_style)
{
- GtkButtonBoxPriv *priv;
+ GtkButtonBoxPrivate *priv;
g_return_if_fail (GTK_IS_BUTTON_BOX (widget));
gint **widths,
gint **heights)
{
- GtkButtonBoxPriv *priv;
+ GtkButtonBoxPrivate *priv;
GtkButtonBox *bbox;
GList *children, *list;
gint nchildren;
gtk_button_box_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
- GtkButtonBoxPriv *priv;
+ GtkButtonBoxPrivate *priv;
GtkButtonBox *bbox;
gint nvis_children;
gint max_size;
gtk_button_box_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
- GtkButtonBoxPriv *priv;
+ GtkButtonBoxPrivate *priv;
GtkButtonBox *bbox;
GList *children, *list;
GtkAllocation child_allocation;
#define GTK_BUTTON_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BUTTON_BOX, GtkButtonBoxClass))
-typedef struct _GtkButtonBox GtkButtonBox;
-typedef struct _GtkButtonBoxPriv GtkButtonBoxPriv;
-typedef struct _GtkButtonBoxClass GtkButtonBoxClass;
+typedef struct _GtkButtonBox GtkButtonBox;
+typedef struct _GtkButtonBoxPrivate GtkButtonBoxPrivate;
+typedef struct _GtkButtonBoxClass GtkButtonBoxClass;
struct _GtkButtonBox
{
GtkBox box;
/*< private >*/
- GtkButtonBoxPriv *priv;
+ GtkButtonBoxPrivate *priv;
};
struct _GtkButtonBoxClass
#include "gtkintl.h"
-struct _GtkBinPriv
+struct _GtkBinPrivate
{
GtkWidget *child;
};
container_class->forall = gtk_bin_forall;
container_class->child_type = gtk_bin_child_type;
- g_type_class_add_private (class, sizeof (GtkBinPriv));
+ g_type_class_add_private (class, sizeof (GtkBinPrivate));
}
static void
gtk_bin_init (GtkBin *bin)
{
- GtkBinPriv *priv;
+ GtkBinPrivate *priv;
bin->priv = G_TYPE_INSTANCE_GET_PRIVATE (bin,
GTK_TYPE_BIN,
- GtkBinPriv);
+ GtkBinPrivate);
priv = bin->priv;
gtk_widget_set_has_window (GTK_WIDGET (bin), FALSE);
static GType
gtk_bin_child_type (GtkContainer *container)
{
- GtkBinPriv *priv = GTK_BIN (container)->priv;
+ GtkBinPrivate *priv = GTK_BIN (container)->priv;
if (!priv->child)
return GTK_TYPE_WIDGET;
GtkWidget *child)
{
GtkBin *bin = GTK_BIN (container);
- GtkBinPriv *priv = bin->priv;
+ GtkBinPrivate *priv = bin->priv;
if (priv->child != NULL)
{
GtkWidget *child)
{
GtkBin *bin = GTK_BIN (container);
- GtkBinPriv *priv = bin->priv;
+ GtkBinPrivate *priv = bin->priv;
gboolean widget_was_visible;
g_return_if_fail (priv->child == child);
gpointer callback_data)
{
GtkBin *bin = GTK_BIN (container);
- GtkBinPriv *priv = bin->priv;
+ GtkBinPrivate *priv = bin->priv;
if (priv->child)
(* callback) (priv->child, callback_data);
gtk_bin_get_request_mode (GtkSizeRequest *widget)
{
GtkBin *bin = GTK_BIN (widget);
- GtkBinPriv *priv = bin->priv;
+ GtkBinPrivate *priv = bin->priv;
if (priv->child)
return gtk_size_request_get_request_mode (GTK_SIZE_REQUEST (priv->child));
gint *delta_h,
gint *delta_v)
{
- GtkBinPriv *priv = bin->priv;
+ GtkBinPrivate *priv = bin->priv;
gint hmin, vmin, child_hmin, child_vmin;
gtk_size_request_get_width (GTK_SIZE_REQUEST (bin), &hmin, NULL);
gint *natural_width)
{
GtkBin *bin = GTK_BIN (widget);
- GtkBinPriv *priv = bin->priv;
+ GtkBinPrivate *priv = bin->priv;
gint hdelta, vdelta, child_min, child_nat;
if (priv->child)
gint *natural_height)
{
GtkBin *bin = GTK_BIN (widget);
- GtkBinPriv *priv = bin->priv;
+ GtkBinPrivate *priv = bin->priv;
gint hdelta, vdelta, child_min, child_nat;
if (priv->child)
#define GTK_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BIN, GtkBinClass))
-typedef struct _GtkBin GtkBin;
-typedef struct _GtkBinPriv GtkBinPriv;
-typedef struct _GtkBinClass GtkBinClass;
+typedef struct _GtkBin GtkBin;
+typedef struct _GtkBinPrivate GtkBinPrivate;
+typedef struct _GtkBinClass GtkBinClass;
struct _GtkBin
{
GtkContainer container;
/*< private >*/
- GtkBinPriv *priv;
+ GtkBinPrivate *priv;
};
struct _GtkBinClass
CHILD_PROP_POSITION
};
-struct _GtkBoxPriv
+struct _GtkBoxPrivate
{
GtkOrientation orientation;
-1, G_MAXINT, 0,
GTK_PARAM_READWRITE));
- g_type_class_add_private (object_class, sizeof (GtkBoxPriv));
+ g_type_class_add_private (object_class, sizeof (GtkBoxPrivate));
}
static void
gtk_box_init (GtkBox *box)
{
- GtkBoxPriv *private;
+ GtkBoxPrivate *private;
box->priv = G_TYPE_INSTANCE_GET_PRIVATE (box,
GTK_TYPE_BOX,
- GtkBoxPriv);
+ GtkBoxPrivate);
private = box->priv;
gtk_widget_set_has_window (GTK_WIDGET (box), FALSE);
GParamSpec *pspec)
{
GtkBox *box = GTK_BOX (object);
- GtkBoxPriv *private = box->priv;
+ GtkBoxPrivate *private = box->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkBox *box = GTK_BOX (object);
- GtkBoxPriv *private = box->priv;
+ GtkBoxPrivate *private = box->priv;
switch (prop_id)
{
gint *visible_children,
gint *expand_children)
{
- GtkBoxPriv *private = box->priv;
+ GtkBoxPrivate *private = box->priv;
GList *children;
GtkBoxChild *child;
GtkAllocation *allocation)
{
GtkBox *box = GTK_BOX (widget);
- GtkBoxPriv *private = box->priv;
+ GtkBoxPrivate *private = box->priv;
GtkBoxChild *child;
GList *children;
gint nvis_children;
guint padding,
GtkPackType pack_type)
{
- GtkBoxPriv *private = box->priv;
+ GtkBoxPrivate *private = box->priv;
GtkBoxChild *child_info;
g_return_if_fail (GTK_IS_BOX (box));
static GtkSizeRequestMode
gtk_box_get_request_mode (GtkSizeRequest *widget)
{
- GtkBoxPriv *private = GTK_BOX (widget)->priv;
+ GtkBoxPrivate *private = GTK_BOX (widget)->priv;
return (private->orientation == GTK_ORIENTATION_VERTICAL) ?
GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH : GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT;
gint *natural_size)
{
GtkBox *box;
- GtkBoxPriv *private;
+ GtkBoxPrivate *private;
GList *children;
gint nvis_children;
gint border_width;
gint *minimum_size,
gint *natural_size)
{
- GtkBoxPriv *private = box->priv;
+ GtkBoxPrivate *private = box->priv;
GtkBoxChild *child;
GList *children;
gint nvis_children;
gint *minimum_size,
gint *natural_size)
{
- GtkBoxPriv *private = box->priv;
+ GtkBoxPrivate *private = box->priv;
GList *children;
gint nvis_children = 0;
gint required_size = 0, required_natural = 0, child_size, child_natural;
gint *natural_width)
{
GtkBox *box = GTK_BOX (widget);
- GtkBoxPriv *private = box->priv;
+ GtkBoxPrivate *private = box->priv;
if (private->orientation == GTK_ORIENTATION_VERTICAL)
gtk_box_compute_size_for_opposing_orientation (box, height, minimum_width, natural_width);
gint *natural_height)
{
GtkBox *box = GTK_BOX (widget);
- GtkBoxPriv *private = box->priv;
+ GtkBoxPrivate *private = box->priv;
if (private->orientation == GTK_ORIENTATION_HORIZONTAL)
gtk_box_compute_size_for_opposing_orientation (box, width, minimum_height, natural_height);
gtk_box_set_homogeneous (GtkBox *box,
gboolean homogeneous)
{
- GtkBoxPriv *private;
+ GtkBoxPrivate *private;
g_return_if_fail (GTK_IS_BOX (box));
gtk_box_set_spacing (GtkBox *box,
gint spacing)
{
- GtkBoxPriv *private;
+ GtkBoxPrivate *private;
g_return_if_fail (GTK_IS_BOX (box));
_gtk_box_set_spacing_set (GtkBox *box,
gboolean spacing_set)
{
- GtkBoxPriv *private;
+ GtkBoxPrivate *private;
g_return_if_fail (GTK_IS_BOX (box));
gboolean
_gtk_box_get_spacing_set (GtkBox *box)
{
- GtkBoxPriv *private;
+ GtkBoxPrivate *private;
g_return_val_if_fail (GTK_IS_BOX (box), FALSE);
GtkWidget *child,
gint position)
{
- GtkBoxPriv *priv;
+ GtkBoxPrivate *priv;
GList *old_link;
GList *new_link;
GtkBoxChild *child_info = NULL;
guint *padding,
GtkPackType *pack_type)
{
- GtkBoxPriv *private;
+ GtkBoxPrivate *private;
GList *list;
GtkBoxChild *child_info = NULL;
guint padding,
GtkPackType pack_type)
{
- GtkBoxPriv *private;
+ GtkBoxPrivate *private;
GList *list;
GtkBoxChild *child_info = NULL;
void
_gtk_box_set_old_defaults (GtkBox *box)
{
- GtkBoxPriv *private;
+ GtkBoxPrivate *private;
g_return_if_fail (GTK_IS_BOX (box));
gtk_box_add (GtkContainer *container,
GtkWidget *widget)
{
- GtkBoxPriv *priv = GTK_BOX (container)->priv;
+ GtkBoxPrivate *priv = GTK_BOX (container)->priv;
gtk_box_pack_start (GTK_BOX (container), widget,
priv->default_expand,
GtkWidget *widget)
{
GtkBox *box = GTK_BOX (container);
- GtkBoxPriv *priv = box->priv;
+ GtkBoxPrivate *priv = box->priv;
GtkBoxChild *child;
GList *children;
gpointer callback_data)
{
GtkBox *box = GTK_BOX (container);
- GtkBoxPriv *priv = box->priv;
+ GtkBoxPrivate *priv = box->priv;
GtkBoxChild *child;
GList *children;
GList *
_gtk_box_get_children (GtkBox *box)
{
- GtkBoxPriv *priv;
+ GtkBoxPrivate *priv;
GtkBoxChild *child;
GList *children;
GList *retval = NULL;
#define GTK_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BOX, GtkBoxClass))
-typedef struct _GtkBox GtkBox;
-typedef struct _GtkBoxPriv GtkBoxPriv;
-typedef struct _GtkBoxClass GtkBoxClass;
+typedef struct _GtkBox GtkBox;
+typedef struct _GtkBoxPrivate GtkBoxPrivate;
+typedef struct _GtkBoxClass GtkBoxClass;
struct _GtkBox
{
GtkContainer container;
/*< private >*/
- GtkBoxPriv *priv;
+ GtkBoxPrivate *priv;
};
struct _GtkBoxClass
-struct _GtkCellRendererPriv
+struct _GtkCellRendererPrivate
{
gfloat xalign;
gfloat yalign;
static void
gtk_cell_renderer_init (GtkCellRenderer *cell)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell,
GTK_TYPE_CELL_RENDERER,
- GtkCellRendererPriv);
+ GtkCellRendererPrivate);
priv = cell->priv;
priv->mode = GTK_CELL_RENDERER_MODE_INERT;
P_("Cell background set"),
P_("Whether this tag affects the cell background color"));
- g_type_class_add_private (class, sizeof (GtkCellRendererPriv));
+ g_type_class_add_private (class, sizeof (GtkCellRendererPrivate));
}
static void
GParamSpec *pspec)
{
GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
- GtkCellRendererPriv *priv = cell->priv;
+ GtkCellRendererPrivate *priv = cell->priv;
switch (param_id)
{
GParamSpec *pspec)
{
GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
- GtkCellRendererPriv *priv = cell->priv;
+ GtkCellRendererPrivate *priv = cell->priv;
switch (param_id)
{
set_cell_bg_color (GtkCellRenderer *cell,
GdkColor *color)
{
- GtkCellRendererPriv *priv = cell->priv;
+ GtkCellRendererPrivate *priv = cell->priv;
if (color)
{
GtkCellRendererState flags)
{
gboolean selected = FALSE;
- GtkCellRendererPriv *priv = cell->priv;
+ GtkCellRendererPrivate *priv = cell->priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->render != NULL);
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
GtkCellRendererState flags)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
GtkCellEditable *editable;
g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), NULL);
gint width,
gint height)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (width >= -1 && height >= -1);
gint *width,
gint *height)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
gfloat xalign,
gfloat yalign)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (xalign >= 0.0 && xalign <= 1.0);
gfloat *xalign,
gfloat *yalign)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
gint xpad,
gint ypad)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (xpad >= 0 && xpad >= 0);
gint *xpad,
gint *ypad)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
gtk_cell_renderer_set_visible (GtkCellRenderer *cell,
gboolean visible)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
gtk_cell_renderer_set_sensitive (GtkCellRenderer *cell,
gboolean sensitive)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
gtk_cell_renderer_stop_editing (GtkCellRenderer *cell,
gboolean canceled)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
gint *x_offset,
gint *y_offset)
{
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (cell_area != NULL);
#define GTK_IS_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER))
#define GTK_CELL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER, GtkCellRendererClass))
-typedef struct _GtkCellRenderer GtkCellRenderer;
-typedef struct _GtkCellRendererPriv GtkCellRendererPriv;
-typedef struct _GtkCellRendererClass GtkCellRendererClass;
+typedef struct _GtkCellRenderer GtkCellRenderer;
+typedef struct _GtkCellRendererPrivate GtkCellRendererPrivate;
+typedef struct _GtkCellRendererClass GtkCellRendererClass;
struct _GtkCellRenderer
{
GtkObject parent;
/* <private> */
- GtkCellRendererPriv *priv;
+ GtkCellRendererPrivate *priv;
};
struct _GtkCellRendererClass
PROP_ACCEL_MODE
};
-struct _GtkCellRendererAccelPriv
+struct _GtkCellRendererAccelPrivate
{
GtkCellRendererAccelMode accel_mode;
cell_accel->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell_accel,
GTK_TYPE_CELL_RENDERER_ACCEL,
- GtkCellRendererAccelPriv);
+ GtkCellRendererAccelPrivate);
text = convert_keysym_state_to_string (cell_accel, 0, 0, 0);
g_object_set (cell_accel, "text", text, NULL);
G_TYPE_NONE, 1,
G_TYPE_STRING);
- g_type_class_add_private (cell_accel_class, sizeof (GtkCellRendererAccelPriv));
+ g_type_class_add_private (cell_accel_class, sizeof (GtkCellRendererAccelPrivate));
}
GdkModifierType mask,
guint keycode)
{
- GtkCellRendererAccelPriv *priv = accel->priv;
+ GtkCellRendererAccelPrivate *priv = accel->priv;
if (keysym == 0 && keycode == 0)
/* This label is displayed in a treeview cell displaying
GValue *value,
GParamSpec *pspec)
{
- GtkCellRendererAccelPriv *priv = GTK_CELL_RENDERER_ACCEL (object)->priv;
+ GtkCellRendererAccelPrivate *priv = GTK_CELL_RENDERER_ACCEL (object)->priv;
switch (param_id)
{
GParamSpec *pspec)
{
GtkCellRendererAccel *accel = GTK_CELL_RENDERER_ACCEL (object);
- GtkCellRendererAccelPriv *priv = accel->priv;
+ GtkCellRendererAccelPrivate *priv = accel->priv;
gboolean changed = FALSE;
switch (param_id)
gint *height)
{
- GtkCellRendererAccelPriv *priv = GTK_CELL_RENDERER_ACCEL (cell)->priv;
+ GtkCellRendererAccelPrivate *priv = GTK_CELL_RENDERER_ACCEL (cell)->priv;
GtkRequisition requisition;
if (priv->sizing_label == NULL)
GdkEventKey *event,
GtkCellRendererAccel *accel)
{
- GtkCellRendererAccelPriv *priv = accel->priv;
+ GtkCellRendererAccelPrivate *priv = accel->priv;
GdkModifierType accel_mods = 0;
guint accel_key;
gchar *path;
ungrab_stuff (GtkWidget *widget,
GtkCellRendererAccel *accel)
{
- GtkCellRendererAccelPriv *priv = accel->priv;
+ GtkCellRendererAccelPrivate *priv = accel->priv;
gtk_device_grab_remove (priv->grab_widget, priv->grab_pointer);
gdk_device_ungrab (priv->grab_keyboard, GDK_CURRENT_TIME);
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
- GtkCellRendererAccelPriv *priv;
+ GtkCellRendererAccelPrivate *priv;
GtkCellRendererText *celltext;
GtkCellRendererAccel *accel;
GtkStyle *style;
#define GTK_IS_CELL_RENDERER_ACCEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_ACCEL))
#define GTK_CELL_RENDERER_ACCEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_ACCEL, GtkCellRendererAccelClass))
-typedef struct _GtkCellRendererAccel GtkCellRendererAccel;
-typedef struct _GtkCellRendererAccelPriv GtkCellRendererAccelPriv;
-typedef struct _GtkCellRendererAccelClass GtkCellRendererAccelClass;
+typedef struct _GtkCellRendererAccel GtkCellRendererAccel;
+typedef struct _GtkCellRendererAccelPrivate GtkCellRendererAccelPrivate;
+typedef struct _GtkCellRendererAccelClass GtkCellRendererAccelClass;
typedef enum
GtkCellRendererText parent;
/*< private >*/
- GtkCellRendererAccelPriv *priv;
+ GtkCellRendererAccelPrivate *priv;
};
struct _GtkCellRendererAccelClass
#include "gtkmarshalers.h"
#include "gtkprivate.h"
-struct _GtkCellRendererComboPriv
+struct _GtkCellRendererComboPrivate
{
GtkTreeModel *model;
G_TYPE_STRING,
GTK_TYPE_TREE_ITER);
- g_type_class_add_private (klass, sizeof (GtkCellRendererComboPriv));
+ g_type_class_add_private (klass, sizeof (GtkCellRendererComboPrivate));
}
static void
gtk_cell_renderer_combo_init (GtkCellRendererCombo *self)
{
- GtkCellRendererComboPriv *priv;
+ GtkCellRendererComboPrivate *priv;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
GTK_TYPE_CELL_RENDERER_COMBO,
- GtkCellRendererComboPriv);
+ GtkCellRendererComboPrivate);
priv = self->priv;
priv->model = NULL;
gtk_cell_renderer_combo_finalize (GObject *object)
{
GtkCellRendererCombo *cell = GTK_CELL_RENDERER_COMBO (object);
- GtkCellRendererComboPriv *priv = cell->priv;
+ GtkCellRendererComboPrivate *priv = cell->priv;
if (priv->model)
{
GParamSpec *pspec)
{
GtkCellRendererCombo *cell = GTK_CELL_RENDERER_COMBO (object);
- GtkCellRendererComboPriv *priv = cell->priv;
+ GtkCellRendererComboPrivate *priv = cell->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkCellRendererCombo *cell = GTK_CELL_RENDERER_COMBO (object);
- GtkCellRendererComboPriv *priv = cell->priv;
+ GtkCellRendererComboPrivate *priv = cell->priv;
switch (prop_id)
{
GtkCellRendererCombo *cell;
GtkEntry *entry;
gboolean canceled;
- GtkCellRendererComboPriv *priv;
+ GtkCellRendererComboPrivate *priv;
cell = GTK_CELL_RENDERER_COMBO (data);
priv = cell->priv;
GtkTreeIter *iter,
gpointer data)
{
- GtkCellRendererComboPriv *priv;
+ GtkCellRendererComboPrivate *priv;
SearchData *search_data = (SearchData *)data;
gchar *text, *cell_text;
GtkCellRendererText *cell_text;
GtkWidget *combo;
SearchData search_data;
- GtkCellRendererComboPriv *priv;
+ GtkCellRendererComboPrivate *priv;
gboolean editable;
gchar *text;
#define GTK_IS_CELL_RENDERER_COMBO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_COMBO))
#define GTK_CELL_RENDERER_COMBO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_COMBO, GtkCellRendererTextClass))
-typedef struct _GtkCellRendererCombo GtkCellRendererCombo;
-typedef struct _GtkCellRendererComboPriv GtkCellRendererComboPriv;
-typedef struct _GtkCellRendererComboClass GtkCellRendererComboClass;
+typedef struct _GtkCellRendererCombo GtkCellRendererCombo;
+typedef struct _GtkCellRendererComboPrivate GtkCellRendererComboPrivate;
+typedef struct _GtkCellRendererComboClass GtkCellRendererComboClass;
struct _GtkCellRendererCombo
{
GtkCellRendererText parent;
/* <private> */
- GtkCellRendererComboPriv *priv;
+ GtkCellRendererComboPrivate *priv;
};
struct _GtkCellRendererComboClass
};
-struct _GtkCellRendererPixbufPriv
+struct _GtkCellRendererPixbufPrivate
{
GtkIconSize stock_size;
static void
gtk_cell_renderer_pixbuf_init (GtkCellRendererPixbuf *cellpixbuf)
{
- GtkCellRendererPixbufPriv *priv;
+ GtkCellRendererPixbufPrivate *priv;
cellpixbuf->priv = G_TYPE_INSTANCE_GET_PRIVATE (cellpixbuf,
GTK_TYPE_CELL_RENDERER_PIXBUF,
- GtkCellRendererPixbufPriv);
+ GtkCellRendererPixbufPrivate);
priv = cellpixbuf->priv;
priv->stock_size = GTK_ICON_SIZE_MENU;
- g_type_class_add_private (object_class, sizeof (GtkCellRendererPixbufPriv));
+ g_type_class_add_private (object_class, sizeof (GtkCellRendererPixbufPrivate));
}
static void
gtk_cell_renderer_pixbuf_finalize (GObject *object)
{
GtkCellRendererPixbuf *cellpixbuf = GTK_CELL_RENDERER_PIXBUF (object);
- GtkCellRendererPixbufPriv *priv = cellpixbuf->priv;
+ GtkCellRendererPixbufPrivate *priv = cellpixbuf->priv;
if (priv->pixbuf)
g_object_unref (priv->pixbuf);
GParamSpec *pspec)
{
GtkCellRendererPixbuf *cellpixbuf = GTK_CELL_RENDERER_PIXBUF (object);
- GtkCellRendererPixbufPriv *priv = cellpixbuf->priv;
+ GtkCellRendererPixbufPrivate *priv = cellpixbuf->priv;
switch (param_id)
{
GParamSpec *pspec)
{
GtkCellRendererPixbuf *cellpixbuf = GTK_CELL_RENDERER_PIXBUF (object);
- GtkCellRendererPixbufPriv *priv = cellpixbuf->priv;
+ GtkCellRendererPixbufPrivate *priv = cellpixbuf->priv;
switch (param_id)
{
gtk_cell_renderer_pixbuf_create_stock_pixbuf (GtkCellRendererPixbuf *cellpixbuf,
GtkWidget *widget)
{
- GtkCellRendererPixbufPriv *priv = cellpixbuf->priv;
+ GtkCellRendererPixbufPrivate *priv = cellpixbuf->priv;
if (priv->pixbuf)
g_object_unref (priv->pixbuf);
gtk_cell_renderer_pixbuf_create_themed_pixbuf (GtkCellRendererPixbuf *cellpixbuf,
GtkWidget *widget)
{
- GtkCellRendererPixbufPriv *priv = cellpixbuf->priv;
+ GtkCellRendererPixbufPrivate *priv = cellpixbuf->priv;
GdkScreen *screen;
GtkIconTheme *icon_theme;
GtkSettings *settings;
GtkWidget *widget,
GtkStateType state)
{
- GtkCellRendererPixbufPriv *priv = cellpixbuf->priv;
+ GtkCellRendererPixbufPrivate *priv = cellpixbuf->priv;
GdkScreen *screen;
GtkIconTheme *icon_theme;
GtkSettings *settings;
gint *height)
{
GtkCellRendererPixbuf *cellpixbuf = (GtkCellRendererPixbuf *) cell;
- GtkCellRendererPixbufPriv *priv = cellpixbuf->priv;
+ GtkCellRendererPixbufPrivate *priv = cellpixbuf->priv;
gint pixbuf_width = 0;
gint pixbuf_height = 0;
gint calc_width;
{
GtkCellRendererPixbuf *cellpixbuf = (GtkCellRendererPixbuf *) cell;
- GtkCellRendererPixbufPriv *priv = cellpixbuf->priv;
+ GtkCellRendererPixbufPrivate *priv = cellpixbuf->priv;
GdkPixbuf *pixbuf;
GdkPixbuf *invisible = NULL;
GdkPixbuf *colorized = NULL;
#define GTK_IS_CELL_RENDERER_PIXBUF_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_PIXBUF))
#define GTK_CELL_RENDERER_PIXBUF_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF, GtkCellRendererPixbufClass))
-typedef struct _GtkCellRendererPixbuf GtkCellRendererPixbuf;
-typedef struct _GtkCellRendererPixbufPriv GtkCellRendererPixbufPriv;
-typedef struct _GtkCellRendererPixbufClass GtkCellRendererPixbufClass;
+typedef struct _GtkCellRendererPixbuf GtkCellRendererPixbuf;
+typedef struct _GtkCellRendererPixbufPrivate GtkCellRendererPixbufPrivate;
+typedef struct _GtkCellRendererPixbufClass GtkCellRendererPixbufClass;
struct _GtkCellRendererPixbuf
{
GtkCellRenderer parent;
/*< private >*/
- GtkCellRendererPixbufPriv *priv;
+ GtkCellRendererPixbufPrivate *priv;
};
struct _GtkCellRendererPixbufClass
#define GTK_CELL_RENDERER_TEXT_PATH "gtk-cell-renderer-text-path"
-struct _GtkCellRendererTextPriv
+struct _GtkCellRendererTextPrivate
{
GtkWidget *entry;
static void
gtk_cell_renderer_text_init (GtkCellRendererText *celltext)
{
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
GtkCellRenderer *cell = GTK_CELL_RENDERER (celltext);
celltext->priv = G_TYPE_INSTANCE_GET_PRIVATE (celltext,
GTK_TYPE_CELL_RENDERER_TEXT,
- GtkCellRendererTextPriv);
+ GtkCellRendererTextPrivate);
priv = celltext->priv;
gtk_cell_renderer_set_alignment (cell, 0.0, 0.5);
G_TYPE_STRING,
G_TYPE_STRING);
- g_type_class_add_private (object_class, sizeof (GtkCellRendererTextPriv));
+ g_type_class_add_private (object_class, sizeof (GtkCellRendererTextPrivate));
}
static void
gtk_cell_renderer_text_finalize (GObject *object)
{
GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (object);
- GtkCellRendererTextPriv *priv = celltext->priv;
+ GtkCellRendererTextPrivate *priv = celltext->priv;
pango_font_description_free (priv->font);
GParamSpec *pspec)
{
GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (object);
- GtkCellRendererTextPriv *priv = celltext->priv;
+ GtkCellRendererTextPrivate *priv = celltext->priv;
switch (param_id)
{
set_bg_color (GtkCellRendererText *celltext,
GdkColor *color)
{
- GtkCellRendererTextPriv *priv = celltext->priv;
+ GtkCellRendererTextPrivate *priv = celltext->priv;
if (color)
{
set_fg_color (GtkCellRendererText *celltext,
GdkColor *color)
{
- GtkCellRendererTextPriv *priv = celltext->priv;
+ GtkCellRendererTextPrivate *priv = celltext->priv;
if (color)
{
set_font_description (GtkCellRendererText *celltext,
PangoFontDescription *font_desc)
{
- GtkCellRendererTextPriv *priv = celltext->priv;
+ GtkCellRendererTextPrivate *priv = celltext->priv;
GObject *object = G_OBJECT (celltext);
PangoFontDescription *new_font_desc;
PangoFontMask old_mask, new_mask, changed_mask, set_changed_mask;
GParamSpec *pspec)
{
GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (object);
- GtkCellRendererTextPriv *priv = celltext->priv;
+ GtkCellRendererTextPrivate *priv = celltext->priv;
switch (param_id)
{
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
- GtkCellRendererTextPriv *priv = celltext->priv;
+ GtkCellRendererTextPrivate *priv = celltext->priv;
PangoAttrList *attr_list;
PangoLayout *layout;
PangoUnderline uline;
gint *height)
{
GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (cell);
- GtkCellRendererTextPriv *priv = celltext->priv;
+ GtkCellRendererTextPrivate *priv = celltext->priv;
PangoRectangle rect;
gint xpad, ypad;
gint cell_width, cell_height;
{
GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (cell);
- GtkCellRendererTextPriv *priv = celltext->priv;
+ GtkCellRendererTextPrivate *priv = celltext->priv;
PangoLayout *layout;
GtkStateType state;
gint x_offset = 0;
gtk_cell_renderer_text_editing_done (GtkCellEditable *entry,
gpointer data)
{
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
const gchar *path;
const gchar *new_text;
gboolean canceled;
static gboolean
popdown_timeout (gpointer data)
{
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
priv = GTK_CELL_RENDERER_TEXT (data)->priv;
gtk_cell_renderer_text_popup_unmap (GtkMenu *menu,
gpointer data)
{
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
priv = GTK_CELL_RENDERER_TEXT (data)->priv;
GtkMenu *menu,
gpointer data)
{
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
priv = GTK_CELL_RENDERER_TEXT (data)->priv;
GdkEvent *event,
gpointer data)
{
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
priv = GTK_CELL_RENDERER_TEXT (data)->priv;
{
GtkRequisition requisition;
GtkCellRendererText *celltext;
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
gfloat xalign, yalign;
celltext = GTK_CELL_RENDERER_TEXT (cell);
gtk_cell_renderer_text_set_fixed_height_from_font (GtkCellRendererText *renderer,
gint number_of_rows)
{
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
GtkCellRenderer *cell;
g_return_if_fail (GTK_IS_CELL_RENDERER_TEXT (renderer));
gint *minimum_size,
gint *natural_size)
{
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
GtkCellRendererText *celltext;
GtkStyle *style;
PangoLayout *layout;
gint *minimum_height,
gint *natural_height)
{
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
GtkCellRendererText *celltext;
PangoLayout *layout;
gint text_height, xpad, ypad;
#define GTK_IS_CELL_RENDERER_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_TEXT))
#define GTK_CELL_RENDERER_TEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_TEXT, GtkCellRendererTextClass))
-typedef struct _GtkCellRendererText GtkCellRendererText;
-typedef struct _GtkCellRendererTextPriv GtkCellRendererTextPriv;
-typedef struct _GtkCellRendererTextClass GtkCellRendererTextClass;
+typedef struct _GtkCellRendererText GtkCellRendererText;
+typedef struct _GtkCellRendererTextPrivate GtkCellRendererTextPrivate;
+typedef struct _GtkCellRendererTextClass GtkCellRendererTextClass;
struct _GtkCellRendererText
{
GtkCellRenderer parent;
/*< private >*/
- GtkCellRendererTextPriv *priv;
+ GtkCellRendererTextPrivate *priv;
};
struct _GtkCellRendererTextClass
static guint toggle_cell_signals[LAST_SIGNAL] = { 0 };
-struct _GtkCellRendererTogglePriv
+struct _GtkCellRendererTogglePrivate
{
gint indicator_size;
static void
gtk_cell_renderer_toggle_init (GtkCellRendererToggle *celltoggle)
{
- GtkCellRendererTogglePriv *priv;
+ GtkCellRendererTogglePrivate *priv;
celltoggle->priv = G_TYPE_INSTANCE_GET_PRIVATE (celltoggle,
GTK_TYPE_CELL_RENDERER_TOGGLE,
- GtkCellRendererTogglePriv);
+ GtkCellRendererTogglePrivate);
priv = celltoggle->priv;
priv->activatable = TRUE;
G_TYPE_NONE, 1,
G_TYPE_STRING);
- g_type_class_add_private (object_class, sizeof (GtkCellRendererTogglePriv));
+ g_type_class_add_private (object_class, sizeof (GtkCellRendererTogglePrivate));
}
static void
GParamSpec *pspec)
{
GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (object);
- GtkCellRendererTogglePriv *priv = celltoggle->priv;
+ GtkCellRendererTogglePrivate *priv = celltoggle->priv;
switch (param_id)
{
GParamSpec *pspec)
{
GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (object);
- GtkCellRendererTogglePriv *priv = celltoggle->priv;
+ GtkCellRendererTogglePrivate *priv = celltoggle->priv;
switch (param_id)
{
gint *width,
gint *height)
{
- GtkCellRendererTogglePriv *priv;
+ GtkCellRendererTogglePrivate *priv;
gint calc_width;
gint calc_height;
gint xpad, ypad;
GtkCellRendererState flags)
{
GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (cell);
- GtkCellRendererTogglePriv *priv = celltoggle->priv;
+ GtkCellRendererTogglePrivate *priv = celltoggle->priv;
gint width, height;
gint x_offset, y_offset;
gint xpad, ypad;
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
- GtkCellRendererTogglePriv *priv;
+ GtkCellRendererTogglePrivate *priv;
GtkCellRendererToggle *celltoggle;
celltoggle = GTK_CELL_RENDERER_TOGGLE (cell);
gtk_cell_renderer_toggle_set_radio (GtkCellRendererToggle *toggle,
gboolean radio)
{
- GtkCellRendererTogglePriv *priv;
+ GtkCellRendererTogglePrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle));
gtk_cell_renderer_toggle_set_activatable (GtkCellRendererToggle *toggle,
gboolean setting)
{
- GtkCellRendererTogglePriv *priv;
+ GtkCellRendererTogglePrivate *priv;
g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle));
#define GTK_IS_CELL_RENDERER_TOGGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_TOGGLE))
#define GTK_CELL_RENDERER_TOGGLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_TOGGLE, GtkCellRendererToggleClass))
-typedef struct _GtkCellRendererToggle GtkCellRendererToggle;
-typedef struct _GtkCellRendererTogglePriv GtkCellRendererTogglePriv;
-typedef struct _GtkCellRendererToggleClass GtkCellRendererToggleClass;
+typedef struct _GtkCellRendererToggle GtkCellRendererToggle;
+typedef struct _GtkCellRendererTogglePrivate GtkCellRendererTogglePrivate;
+typedef struct _GtkCellRendererToggleClass GtkCellRendererToggleClass;
struct _GtkCellRendererToggle
{
GtkCellRenderer parent;
/*< private >*/
- GtkCellRendererTogglePriv *priv;
+ GtkCellRendererTogglePrivate *priv;
};
struct _GtkCellRendererToggleClass
-struct _GtkCheckMenuItemPriv
+struct _GtkCheckMenuItemPrivate
{
guint active : 1;
guint always_show_toggle : 1;
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- g_type_class_add_private (klass, sizeof (GtkCheckMenuItemPriv));
+ g_type_class_add_private (klass, sizeof (GtkCheckMenuItemPrivate));
}
static void
gtk_check_menu_item_set_active (GtkCheckMenuItem *check_menu_item,
gboolean is_active)
{
- GtkCheckMenuItemPriv *priv;
+ GtkCheckMenuItemPrivate *priv;
g_return_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item));
gtk_check_menu_item_set_inconsistent (GtkCheckMenuItem *check_menu_item,
gboolean setting)
{
- GtkCheckMenuItemPriv *priv;
+ GtkCheckMenuItemPrivate *priv;
g_return_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item));
gtk_check_menu_item_set_draw_as_radio (GtkCheckMenuItem *check_menu_item,
gboolean draw_as_radio)
{
- GtkCheckMenuItemPriv *priv;
+ GtkCheckMenuItemPrivate *priv;
g_return_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item));
static void
gtk_check_menu_item_init (GtkCheckMenuItem *check_menu_item)
{
- GtkCheckMenuItemPriv *priv;
+ GtkCheckMenuItemPrivate *priv;
check_menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (check_menu_item,
GTK_TYPE_CHECK_MENU_ITEM,
- GtkCheckMenuItemPriv);
+ GtkCheckMenuItemPrivate);
priv = check_menu_item->priv;
priv->active = FALSE;
static void
gtk_check_menu_item_activate (GtkMenuItem *menu_item)
{
- GtkCheckMenuItemPriv *priv;
+ GtkCheckMenuItemPrivate *priv;
GtkCheckMenuItem *check_menu_item = GTK_CHECK_MENU_ITEM (menu_item);
priv = check_menu_item->priv;
gtk_real_check_menu_item_draw_indicator (GtkCheckMenuItem *check_menu_item,
GdkRectangle *area)
{
- GtkCheckMenuItemPriv *priv = check_menu_item->priv;
+ GtkCheckMenuItemPrivate *priv = check_menu_item->priv;
GtkWidget *widget;
GtkStateType state_type;
GtkShadowType shadow_type;
GParamSpec *pspec)
{
GtkCheckMenuItem *checkitem = GTK_CHECK_MENU_ITEM (object);
- GtkCheckMenuItemPriv *priv = checkitem->priv;
+ GtkCheckMenuItemPrivate *priv = checkitem->priv;
switch (prop_id)
{
_gtk_check_menu_item_set_active (GtkCheckMenuItem *check_menu_item,
gboolean is_active)
{
- GtkCheckMenuItemPriv *priv = check_menu_item->priv;
+ GtkCheckMenuItemPrivate *priv = check_menu_item->priv;
priv->active = is_active;
}
#define GTK_CHECK_MENU_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CHECK_MENU_ITEM, GtkCheckMenuItemClass))
-typedef struct _GtkCheckMenuItem GtkCheckMenuItem;
-typedef struct _GtkCheckMenuItemPriv GtkCheckMenuItemPriv;
-typedef struct _GtkCheckMenuItemClass GtkCheckMenuItemClass;
+typedef struct _GtkCheckMenuItem GtkCheckMenuItem;
+typedef struct _GtkCheckMenuItemPrivate GtkCheckMenuItemPrivate;
+typedef struct _GtkCheckMenuItemClass GtkCheckMenuItemClass;
struct _GtkCheckMenuItem
{
GtkMenuItem menu_item;
/* <private> */
- GtkCheckMenuItemPriv *priv;
+ GtkCheckMenuItemPrivate *priv;
};
struct _GtkCheckMenuItemClass
-struct _GtkColorSelectionDialogPriv
+struct _GtkColorSelectionDialogPrivate
{
GtkWidget *colorsel;
GtkWidget *ok_button;
GParamSpec *pspec)
{
GtkColorSelectionDialog *colorsel = GTK_COLOR_SELECTION_DIALOG (object);
- GtkColorSelectionDialogPriv *priv = colorsel->priv;
+ GtkColorSelectionDialogPrivate *priv = colorsel->priv;
switch (prop_id)
{
GTK_TYPE_WIDGET,
G_PARAM_READABLE));
- g_type_class_add_private (klass, sizeof (GtkColorSelectionDialogPriv));
+ g_type_class_add_private (klass, sizeof (GtkColorSelectionDialogPrivate));
}
static void
gtk_color_selection_dialog_init (GtkColorSelectionDialog *colorseldiag)
{
- GtkColorSelectionDialogPriv *priv;
+ GtkColorSelectionDialogPrivate *priv;
GtkDialog *dialog = GTK_DIALOG (colorseldiag);
GtkWidget *action_area, *content_area;
colorseldiag->priv = G_TYPE_INSTANCE_GET_PRIVATE (colorseldiag,
GTK_TYPE_COLOR_SELECTION_DIALOG,
- GtkColorSelectionDialogPriv);
+ GtkColorSelectionDialogPrivate);
priv = colorseldiag->priv;
content_area = gtk_dialog_get_content_area (dialog);
const gchar *childname)
{
GtkColorSelectionDialog *selection_dialog = GTK_COLOR_SELECTION_DIALOG (buildable);
- GtkColorSelectionDialogPriv *priv = selection_dialog->priv;
+ GtkColorSelectionDialogPrivate *priv = selection_dialog->priv;
if (g_strcmp0 (childname, "ok_button") == 0)
return G_OBJECT (priv->ok_button);
#define GTK_COLOR_SELECTION_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COLOR_SELECTION_DIALOG, GtkColorSelectionDialogClass))
-typedef struct _GtkColorSelectionDialog GtkColorSelectionDialog;
-typedef struct _GtkColorSelectionDialogPriv GtkColorSelectionDialogPriv;
-typedef struct _GtkColorSelectionDialogClass GtkColorSelectionDialogClass;
+typedef struct _GtkColorSelectionDialog GtkColorSelectionDialog;
+typedef struct _GtkColorSelectionDialogPrivate GtkColorSelectionDialogPrivate;
+typedef struct _GtkColorSelectionDialogClass GtkColorSelectionDialogClass;
struct _GtkColorSelectionDialog
GtkDialog parent_instance;
/* <private> */
- GtkColorSelectionDialogPriv *priv;
+ GtkColorSelectionDialogPrivate *priv;
};
struct _GtkColorSelectionDialogClass
#include <gobject/gobjectnotifyqueue.c>
#include <gobject/gvaluecollector.h>
-struct _GtkContainerPriv
+struct _GtkContainerPrivate
{
GtkWidget *focus_child;
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
- g_type_class_add_private (class, sizeof (GtkContainerPriv));
+ g_type_class_add_private (class, sizeof (GtkContainerPrivate));
}
static void
static void
gtk_container_init (GtkContainer *container)
{
- GtkContainerPriv *priv;
+ GtkContainerPrivate *priv;
container->priv = G_TYPE_INSTANCE_GET_PRIVATE (container,
GTK_TYPE_CONTAINER,
- GtkContainerPriv);
+ GtkContainerPrivate);
priv = container->priv;
priv->focus_child = NULL;
gtk_container_destroy (GtkObject *object)
{
GtkContainer *container = GTK_CONTAINER (object);
- GtkContainerPriv *priv = container->priv;
+ GtkContainerPrivate *priv = container->priv;
if (GTK_CONTAINER_RESIZE_PENDING (container))
_gtk_container_dequeue_resize_handler (container);
GParamSpec *pspec)
{
GtkContainer *container = GTK_CONTAINER (object);
- GtkContainerPriv *priv = container->priv;
+ GtkContainerPrivate *priv = container->priv;
switch (prop_id)
{
gtk_container_set_border_width (GtkContainer *container,
guint border_width)
{
- GtkContainerPriv *priv;
+ GtkContainerPrivate *priv;
g_return_if_fail (GTK_IS_CONTAINER (container));
gtk_container_set_resize_mode (GtkContainer *container,
GtkResizeMode resize_mode)
{
- GtkContainerPriv *priv;
+ GtkContainerPrivate *priv;
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (resize_mode <= GTK_RESIZE_IMMEDIATE);
void
_gtk_container_queue_resize (GtkContainer *container)
{
- GtkContainerPriv *priv;
+ GtkContainerPrivate *priv;
GtkContainer *resize_container;
GtkWidget *parent;
GtkWidget *widget;
gtk_container_real_set_focus_child (GtkContainer *container,
GtkWidget *child)
{
- GtkContainerPriv *priv;
+ GtkContainerPrivate *priv;
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (child == NULL || GTK_IS_WIDGET (child));
GList *sorted_children;
gint return_val;
GtkContainer *container;
- GtkContainerPriv *priv;
+ GtkContainerPrivate *priv;
g_return_val_if_fail (GTK_IS_CONTAINER (widget), FALSE);
GList *children,
GtkDirectionType direction)
{
- GtkContainerPriv *priv = container->priv;
+ GtkContainerPrivate *priv = container->priv;
GtkWidget *focus_child;
GtkWidget *child;
{
GList *chain;
GList *tmp_list;
- GtkContainerPriv *priv;
+ GtkContainerPrivate *priv;
g_return_if_fail (GTK_IS_CONTAINER (container));
gtk_container_get_focus_chain (GtkContainer *container,
GList **focus_chain)
{
- GtkContainerPriv *priv;
+ GtkContainerPrivate *priv;
g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
void
gtk_container_unset_focus_chain (GtkContainer *container)
{
- GtkContainerPriv *priv;
+ GtkContainerPrivate *priv;
g_return_if_fail (GTK_IS_CONTAINER (container));
#define GTK_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CONTAINER, GtkContainerClass))
-typedef struct _GtkContainer GtkContainer;
-typedef struct _GtkContainerPriv GtkContainerPriv;
-typedef struct _GtkContainerClass GtkContainerClass;
+typedef struct _GtkContainer GtkContainer;
+typedef struct _GtkContainerPrivate GtkContainerPrivate;
+typedef struct _GtkContainerClass GtkContainerClass;
struct _GtkContainer
{
GtkWidget widget;
/*< private >*/
- GtkContainerPriv *priv;
+ GtkContainerPrivate *priv;
};
struct _GtkContainerClass
#include "gtkbuildable.h"
-struct _GtkDialogPriv
+struct _GtkDialogPrivate
{
GtkWidget *vbox;
GtkWidget *action_area;
class->close = gtk_dialog_close;
- g_type_class_add_private (gobject_class, sizeof (GtkDialogPriv));
+ g_type_class_add_private (gobject_class, sizeof (GtkDialogPrivate));
/**
* GtkDialog:has-separator:
static void
update_spacings (GtkDialog *dialog)
{
- GtkDialogPriv *priv = dialog->priv;
+ GtkDialogPrivate *priv = dialog->priv;
gint content_area_border;
gint content_area_spacing;
gint button_spacing;
static void
gtk_dialog_init (GtkDialog *dialog)
{
- GtkDialogPriv *priv;
+ GtkDialogPrivate *priv;
dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog,
GTK_TYPE_DIALOG,
- GtkDialogPriv);
+ GtkDialogPrivate);
priv = dialog->priv;
priv->ignore_separator = FALSE;
GtkBuilder *builder,
const gchar *childname)
{
- GtkDialogPriv *priv = GTK_DIALOG (buildable)->priv;
+ GtkDialogPrivate *priv = GTK_DIALOG (buildable)->priv;
if (strcmp (childname, "vbox") == 0)
return G_OBJECT (priv->vbox);
GParamSpec *pspec)
{
GtkDialog *dialog = GTK_DIALOG (object);
- GtkDialogPriv *priv = dialog->priv;
+ GtkDialogPrivate *priv = dialog->priv;
switch (prop_id)
{
GtkWidget *default_widget, *focus;
GtkWindow *window = GTK_WINDOW (widget);
GtkDialog *dialog = GTK_DIALOG (widget);
- GtkDialogPriv *priv = dialog->priv;
+ GtkDialogPrivate *priv = dialog->priv;
GTK_WIDGET_CLASS (gtk_dialog_parent_class)->map (widget);
dialog_find_button (GtkDialog *dialog,
gint response_id)
{
- GtkDialogPriv *priv = dialog->priv;
+ GtkDialogPrivate *priv = dialog->priv;
GtkWidget *child = NULL;
GList *children, *tmp_list;
GtkWidget *child,
gint response_id)
{
- GtkDialogPriv *priv;
+ GtkDialogPrivate *priv;
ResponseData *ad;
guint signal_id;
gint response_id,
gboolean setting)
{
- GtkDialogPriv *priv;
+ GtkDialogPrivate *priv;
GList *children;
GList *tmp_list;
gtk_dialog_set_default_response (GtkDialog *dialog,
gint response_id)
{
- GtkDialogPriv *priv;
+ GtkDialogPrivate *priv;
GList *children;
GList *tmp_list;
gtk_dialog_set_has_separator (GtkDialog *dialog,
gboolean setting)
{
- GtkDialogPriv *priv;
+ GtkDialogPrivate *priv;
g_return_if_fail (GTK_IS_DIALOG (dialog));
_gtk_dialog_set_ignore_separator (GtkDialog *dialog,
gboolean ignore_separator)
{
- GtkDialogPriv *priv = dialog->priv;
+ GtkDialogPrivate *priv = dialog->priv;
priv->ignore_separator = ignore_separator;
}
gtk_dialog_get_widget_for_response (GtkDialog *dialog,
gint response_id)
{
- GtkDialogPriv *priv;
+ GtkDialogPrivate *priv;
GList *children;
GList *tmp_list;
gint first_response_id,
va_list args)
{
- GtkDialogPriv *priv = dialog->priv;
+ GtkDialogPrivate *priv = dialog->priv;
GtkWidget *child;
gint response_id;
gint position;
gint n_params,
gint *new_order)
{
- GtkDialogPriv *priv = dialog->priv;
+ GtkDialogPrivate *priv = dialog->priv;
GdkScreen *screen;
GtkWidget *child;
gint position;
gpointer user_data)
{
GtkDialog *dialog = GTK_DIALOG (buildable);
- GtkDialogPriv *priv = dialog->priv;
+ GtkDialogPrivate *priv = dialog->priv;
GSList *l;
ActionWidgetsSubParserData *parser_data;
GObject *object;
#define GTK_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_DIALOG, GtkDialogClass))
-typedef struct _GtkDialog GtkDialog;
-typedef struct _GtkDialogPriv GtkDialogPriv;
-typedef struct _GtkDialogClass GtkDialogClass;
+typedef struct _GtkDialog GtkDialog;
+typedef struct _GtkDialogPrivate GtkDialogPrivate;
+typedef struct _GtkDialogClass GtkDialogClass;
struct _GtkDialog
{
GtkWindow window;
/*< private >*/
- GtkDialogPriv *priv;
+ GtkDialogPrivate *priv;
};
struct _GtkDialogClass
typedef struct AsyncFuncData AsyncFuncData;
-struct GtkFileSystemPriv
+struct GtkFileSystemPrivate
{
GVolumeMonitor *volume_monitor;
GFileMonitor *bookmarks_monitor;
};
-struct GtkFolderPriv
+struct GtkFolderPrivate
{
GFile *folder_file;
GHashTable *children;
gtk_file_system_dispose (GObject *object)
{
GtkFileSystem *file_system = GTK_FILE_SYSTEM (object);
- GtkFileSystemPriv *priv = file_system->priv;
+ GtkFileSystemPrivate *priv = file_system->priv;
DEBUG ("dispose");
gtk_file_system_finalize (GObject *object)
{
GtkFileSystem *file_system = GTK_FILE_SYSTEM (object);
- GtkFileSystemPriv *priv = file_system->priv;
+ GtkFileSystemPrivate *priv = file_system->priv;
DEBUG ("finalize");
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- g_type_class_add_private (object_class, sizeof (GtkFileSystemPriv));
+ g_type_class_add_private (object_class, sizeof (GtkFileSystemPrivate));
}
static GFile *
gpointer data)
{
GtkFileSystem *file_system = GTK_FILE_SYSTEM (data);
- GtkFileSystemPriv *priv = file_system->priv;
+ GtkFileSystemPrivate *priv = file_system->priv;
switch (event)
{
static void
get_volumes_list (GtkFileSystem *file_system)
{
- GtkFileSystemPriv *priv = file_system->priv;
+ GtkFileSystemPrivate *priv = file_system->priv;
GList *l, *ll;
GList *drives;
GList *volumes;
static void
_gtk_file_system_init (GtkFileSystem *file_system)
{
- GtkFileSystemPriv *priv;
+ GtkFileSystemPrivate *priv;
GFile *bookmarks_file;
GError *error = NULL;
file_system->priv = G_TYPE_INSTANCE_GET_PRIVATE (file_system,
GTK_TYPE_FILE_SYSTEM,
- GtkFileSystemPriv);
+ GtkFileSystemPrivate);
priv = file_system->priv;
/* Volumes */
GSList *
_gtk_file_system_list_volumes (GtkFileSystem *file_system)
{
- GtkFileSystemPriv *priv = file_system->priv;
+ GtkFileSystemPrivate *priv = file_system->priv;
GSList *list;
DEBUG ("list_volumes");
GSList *
_gtk_file_system_list_bookmarks (GtkFileSystem *file_system)
{
- GtkFileSystemPriv *priv = file_system->priv;
+ GtkFileSystemPrivate *priv = file_system->priv;
GSList *bookmarks, *files = NULL;
DEBUG ("list_bookmarks");
gint position,
GError **error)
{
- GtkFileSystemPriv *priv = file_system->priv;
+ GtkFileSystemPrivate *priv = file_system->priv;
GSList *bookmarks;
GtkFileSystemBookmark *bookmark;
gboolean result = TRUE;
GFile *file,
GError **error)
{
- GtkFileSystemPriv *priv = file_system->priv;
+ GtkFileSystemPrivate *priv = file_system->priv;
GtkFileSystemBookmark *bookmark;
GSList *bookmarks;
gboolean result = FALSE;
_gtk_file_system_get_bookmark_label (GtkFileSystem *file_system,
GFile *file)
{
- GtkFileSystemPriv *priv = file_system->priv;
+ GtkFileSystemPrivate *priv = file_system->priv;
GSList *bookmarks;
gchar *label = NULL;
GFile *file,
const gchar *label)
{
- GtkFileSystemPriv *priv = file_system->priv;
+ GtkFileSystemPrivate *priv = file_system->priv;
gboolean changed = FALSE;
GFile *bookmarks_file;
GSList *bookmarks;
GParamSpec *pspec)
{
GtkFolder *folder = GTK_FOLDER (object);
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkFolder *folder = GTK_FOLDER (object);
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
switch (prop_id)
{
gpointer data)
{
GtkFolder *folder = GTK_FOLDER (data);
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
GSList *files;
files = g_slist_prepend (NULL, file);
gpointer user_data)
{
GtkFolder *folder = GTK_FOLDER (user_data);
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
GFileEnumerator *enumerator;
GError *error = NULL;
GSList *files = NULL;
gtk_folder_constructed (GObject *object)
{
GtkFolder *folder = GTK_FOLDER (object);
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
GError *error = NULL;
priv->directory_monitor = g_file_monitor_directory (priv->folder_file, G_FILE_MONITOR_NONE, NULL, &error);
gtk_folder_finalize (GObject *object)
{
GtkFolder *folder = GTK_FOLDER (object);
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
g_hash_table_unref (priv->children);
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- g_type_class_add_private (object_class, sizeof (GtkFolderPriv));
+ g_type_class_add_private (object_class, sizeof (GtkFolderPrivate));
}
static void
_gtk_folder_init (GtkFolder *folder)
{
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
priv->children = g_hash_table_new_full (g_file_hash,
(GEqualFunc) g_file_equal,
gtk_folder_set_finished_loading (GtkFolder *folder,
gboolean finished_loading)
{
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
priv->finished_loading = (finished_loading == TRUE);
GFile *file,
GFileInfo *info)
{
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
g_hash_table_insert (priv->children,
g_object_ref (file),
GSList *
_gtk_folder_list_children (GtkFolder *folder)
{
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
GList *files, *elem;
GSList *children = NULL;
_gtk_folder_get_info (GtkFolder *folder,
GFile *file)
{
- GtkFolderPriv *priv = folder->priv;
+ GtkFolderPrivate *priv = folder->priv;
GFileInfo *info;
info = g_hash_table_lookup (priv->children, file);
#define GTK_FILE_SYSTEM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_FILE_SYSTEM, GtkFileSystemClass))
typedef struct GtkFileSystem GtkFileSystem;
-typedef struct GtkFileSystemPriv GtkFileSystemPriv;
+typedef struct GtkFileSystemPrivate GtkFileSystemPrivate;
typedef struct GtkFileSystemClass GtkFileSystemClass;
#define GTK_FOLDER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_FOLDER, GtkFolderClass))
typedef struct GtkFolder GtkFolder;
-typedef struct GtkFolderPriv GtkFolderPriv;
+typedef struct GtkFolderPrivate GtkFolderPrivate;
typedef struct GtkFolderClass GtkFolderClass;
typedef struct GtkFileSystemVolume GtkFileSystemVolume; /* opaque struct */
{
GObject parent_object;
- GtkFileSystemPriv *priv;
+ GtkFileSystemPrivate *priv;
};
struct GtkFileSystemClass
{
GObject parent_object;
- GtkFolderPriv *priv;
+ GtkFolderPrivate *priv;
};
struct GtkFolderClass
#include "gtkintl.h"
-struct _GtkFixedPriv
+struct _GtkFixedPrivate
{
GList *children;
};
0,
GTK_PARAM_READWRITE));
- g_type_class_add_private (class, sizeof (GtkFixedPriv));
+ g_type_class_add_private (class, sizeof (GtkFixedPrivate));
}
static GType
static void
gtk_fixed_init (GtkFixed *fixed)
{
- GtkFixedPriv *priv;
+ GtkFixedPrivate *priv;
fixed->priv = G_TYPE_INSTANCE_GET_PRIVATE (fixed,
GTK_TYPE_FIXED,
- GtkFixedPriv);
+ GtkFixedPrivate);
priv = fixed->priv;
gtk_widget_set_has_window (GTK_WIDGET (fixed), FALSE);
get_child (GtkFixed *fixed,
GtkWidget *widget)
{
- GtkFixedPriv *priv = fixed->priv;
+ GtkFixedPrivate *priv = fixed->priv;
GList *children;
children = priv->children;
gint x,
gint y)
{
- GtkFixedPriv *priv = fixed->priv;
+ GtkFixedPrivate *priv = fixed->priv;
GtkFixedChild *child_info;
g_return_if_fail (GTK_IS_FIXED (fixed));
gtk_fixed_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
- GtkFixedPriv *priv;
+ GtkFixedPrivate *priv;
GtkFixed *fixed;
GtkFixedChild *child;
GList *children;
GtkAllocation *allocation)
{
GtkFixed *fixed = GTK_FIXED (widget);
- GtkFixedPriv *priv = fixed->priv;
+ GtkFixedPrivate *priv = fixed->priv;
GtkFixedChild *child;
GtkAllocation child_allocation;
GtkRequisition child_requisition;
GtkWidget *widget)
{
GtkFixed *fixed = GTK_FIXED (container);
- GtkFixedPriv *priv = fixed->priv;
+ GtkFixedPrivate *priv = fixed->priv;
GtkFixedChild *child;
GtkWidget *widget_container = GTK_WIDGET (container);
GList *children;
gpointer callback_data)
{
GtkFixed *fixed = GTK_FIXED (container);
- GtkFixedPriv *priv = fixed->priv;
+ GtkFixedPrivate *priv = fixed->priv;
GtkFixedChild *child;
GList *children;
#define GTK_IS_FIXED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FIXED))
#define GTK_FIXED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FIXED, GtkFixedClass))
-typedef struct _GtkFixed GtkFixed;
-typedef struct _GtkFixedPriv GtkFixedPriv;
-typedef struct _GtkFixedClass GtkFixedClass;
-typedef struct _GtkFixedChild GtkFixedChild;
+typedef struct _GtkFixed GtkFixed;
+typedef struct _GtkFixedPrivate GtkFixedPrivate;
+typedef struct _GtkFixedClass GtkFixedClass;
+typedef struct _GtkFixedChild GtkFixedChild;
struct _GtkFixed
{
GtkContainer container;
/* <private> */
- GtkFixedPriv *priv;
+ GtkFixedPrivate *priv;
};
struct _GtkFixedClass
#include "gtkprivate.h"
#include "gtkbuildable.h"
-struct _GtkFontSelectionPriv
+struct _GtkFontSelectionPrivate
{
GtkWidget *font_entry; /* Used _get_family_entry() for consistency, -mr */
GtkWidget *font_style_entry; /* Used _get_face_entry() for consistency, -mr */
};
-struct _GtkFontSelectionDialogPriv
+struct _GtkFontSelectionDialogPrivate
{
GtkWidget *fontsel;
_(PREVIEW_TEXT),
GTK_PARAM_READWRITE));
- g_type_class_add_private (klass, sizeof (GtkFontSelectionPriv));
+ g_type_class_add_private (klass, sizeof (GtkFontSelectionPrivate));
}
static void
static void
gtk_font_selection_init (GtkFontSelection *fontsel)
{
- GtkFontSelectionPriv *priv;
+ GtkFontSelectionPrivate *priv;
GtkWidget *scrolled_win;
GtkWidget *text_box;
GtkWidget *table, *label;
fontsel->priv = G_TYPE_INSTANCE_GET_PRIVATE (fontsel,
GTK_TYPE_FONT_SELECTION,
- GtkFontSelectionPriv);
+ GtkFontSelectionPrivate);
priv = fontsel->priv;
gtk_widget_push_composite_child ();
gtk_font_selection_ref_family (GtkFontSelection *fontsel,
PangoFontFamily *family)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
if (family)
family = g_object_ref (family);
static void gtk_font_selection_ref_face (GtkFontSelection *fontsel,
PangoFontFace *face)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
if (face)
face = g_object_ref (face);
static void
gtk_font_selection_scroll_to_selection (GtkFontSelection *fontsel)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
/* Try to scroll the font family list to the selected item */
scroll_to_selection (GTK_TREE_VIEW (priv->family_list));
gpointer data)
{
GtkFontSelection *fontsel;
- GtkFontSelectionPriv *priv;
+ GtkFontSelectionPrivate *priv;
GtkTreeModel *model;
GtkTreeIter iter;
#ifdef INCLUDE_FONT_ENTRIES
static void
gtk_font_selection_show_available_fonts (GtkFontSelection *fontsel)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
GtkListStore *model;
PangoFontFamily **families;
PangoFontFamily *match_family = NULL;
static void
gtk_font_selection_show_available_styles (GtkFontSelection *fontsel)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
gint n_faces, i;
PangoFontFace **faces;
PangoFontDescription *old_desc;
gtk_font_selection_select_best_style (GtkFontSelection *fontsel,
gboolean use_first)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
GtkTreeIter iter;
GtkTreeModel *model;
gtk_font_selection_show_available_sizes (GtkFontSelection *fontsel,
gboolean first_time)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
gint i;
GtkListStore *model;
gchar buffer[128];
gtk_font_selection_set_size (GtkFontSelection *fontsel,
gint new_size)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
if (priv->size != new_size)
{
gpointer data)
{
GtkFontSelection *fontsel = GTK_FONT_SELECTION (data);
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
gint new_size;
const gchar *text;
gpointer data)
{
GtkFontSelection *fontsel = GTK_FONT_SELECTION (data);
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
gint new_size;
const gchar *text;
static PangoFontDescription *
gtk_font_selection_get_font_description (GtkFontSelection *fontsel)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
PangoFontDescription *font_desc;
if (priv->face)
static void
gtk_font_selection_update_preview (GtkFontSelection *fontsel)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
GtkRcStyle *rc_style;
gint new_height;
GtkRequisition old_requisition;
PangoFontFamily **pfamily,
PangoFontFace **pface)
{
- GtkFontSelectionPriv *priv = fontsel->priv;
+ GtkFontSelectionPrivate *priv = fontsel->priv;
PangoFontFamily *new_family = NULL;
PangoFontFace *new_face = NULL;
PangoFontFace *fallback_face = NULL;
G_CONST_RETURN gchar*
gtk_font_selection_get_preview_text (GtkFontSelection *fontsel)
{
- GtkFontSelectionPriv *priv;
+ GtkFontSelectionPrivate *priv;
g_return_val_if_fail (GTK_IS_FONT_SELECTION (fontsel), NULL);
gtk_font_selection_set_preview_text (GtkFontSelection *fontsel,
const gchar *text)
{
- GtkFontSelectionPriv *priv;
+ GtkFontSelectionPrivate *priv;
g_return_if_fail (GTK_IS_FONT_SELECTION (fontsel));
g_return_if_fail (text != NULL);
static void
gtk_font_selection_dialog_class_init (GtkFontSelectionDialogClass *klass)
{
- g_type_class_add_private (klass, sizeof (GtkFontSelectionDialogPriv));
+ g_type_class_add_private (klass, sizeof (GtkFontSelectionDialogPrivate));
}
static void
gtk_font_selection_dialog_init (GtkFontSelectionDialog *fontseldiag)
{
- GtkFontSelectionDialogPriv *priv;
+ GtkFontSelectionDialogPrivate *priv;
GtkDialog *dialog = GTK_DIALOG (fontseldiag);
GtkWidget *action_area, *content_area;
fontseldiag->priv = G_TYPE_INSTANCE_GET_PRIVATE (fontseldiag,
GTK_TYPE_FONT_SELECTION_DIALOG,
- GtkFontSelectionDialogPriv);
+ GtkFontSelectionDialogPrivate);
priv = fontseldiag->priv;
content_area = gtk_dialog_get_content_area (dialog);
GtkBuilder *builder,
const gchar *childname)
{
- GtkFontSelectionDialogPriv *priv;
+ GtkFontSelectionDialogPrivate *priv;
priv = GTK_FONT_SELECTION_DIALOG (buildable)->priv;
gchar*
gtk_font_selection_dialog_get_font_name (GtkFontSelectionDialog *fsd)
{
- GtkFontSelectionDialogPriv *priv;
+ GtkFontSelectionDialogPrivate *priv;
g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
gtk_font_selection_dialog_set_font_name (GtkFontSelectionDialog *fsd,
const gchar *fontname)
{
- GtkFontSelectionDialogPriv *priv;
+ GtkFontSelectionDialogPrivate *priv;
g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), FALSE);
g_return_val_if_fail (fontname, FALSE);
G_CONST_RETURN gchar*
gtk_font_selection_dialog_get_preview_text (GtkFontSelectionDialog *fsd)
{
- GtkFontSelectionDialogPriv *priv;
+ GtkFontSelectionDialogPrivate *priv;
g_return_val_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd), NULL);
gtk_font_selection_dialog_set_preview_text (GtkFontSelectionDialog *fsd,
const gchar *text)
{
- GtkFontSelectionDialogPriv *priv;
+ GtkFontSelectionDialogPrivate *priv;
g_return_if_fail (GTK_IS_FONT_SELECTION_DIALOG (fsd));
g_return_if_fail (text != NULL);
#define GTK_FONT_SELECTION_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FONT_SELECTION_DIALOG, GtkFontSelectionDialogClass))
-typedef struct _GtkFontSelection GtkFontSelection;
-typedef struct _GtkFontSelectionPriv GtkFontSelectionPriv;
-typedef struct _GtkFontSelectionClass GtkFontSelectionClass;
+typedef struct _GtkFontSelection GtkFontSelection;
+typedef struct _GtkFontSelectionPrivate GtkFontSelectionPrivate;
+typedef struct _GtkFontSelectionClass GtkFontSelectionClass;
-typedef struct _GtkFontSelectionDialog GtkFontSelectionDialog;
-typedef struct _GtkFontSelectionDialogPriv GtkFontSelectionDialogPriv;
-typedef struct _GtkFontSelectionDialogClass GtkFontSelectionDialogClass;
+typedef struct _GtkFontSelectionDialog GtkFontSelectionDialog;
+typedef struct _GtkFontSelectionDialogPrivate GtkFontSelectionDialogPrivate;
+typedef struct _GtkFontSelectionDialogClass GtkFontSelectionDialogClass;
struct _GtkFontSelection
{
GtkVBox parent_instance;
/* <private> */
- GtkFontSelectionPriv *priv;
+ GtkFontSelectionPrivate *priv;
};
struct _GtkFontSelectionClass
GtkDialog parent_instance;
/*< private >*/
- GtkFontSelectionDialogPriv *priv;
+ GtkFontSelectionDialogPrivate *priv;
};
struct _GtkFontSelectionDialogClass
#define LABEL_PAD 1
#define LABEL_SIDE_PAD 2
-struct _GtkFramePriv
+struct _GtkFramePrivate
{
/* Properties */
GtkWidget *label_widget;
class->compute_child_allocation = gtk_frame_real_compute_child_allocation;
- g_type_class_add_private (class, sizeof (GtkFramePriv));
+ g_type_class_add_private (class, sizeof (GtkFramePrivate));
}
static void
static void
gtk_frame_init (GtkFrame *frame)
{
- GtkFramePriv *priv;
+ GtkFramePrivate *priv;
frame->priv = G_TYPE_INSTANCE_GET_PRIVATE (frame,
GTK_TYPE_FRAME,
- GtkFramePriv);
+ GtkFramePrivate);
priv = frame->priv;
priv->label_widget = NULL;
GParamSpec *pspec)
{
GtkFrame *frame = GTK_FRAME (object);
- GtkFramePriv *priv = frame->priv;
+ GtkFramePrivate *priv = frame->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkFrame *frame = GTK_FRAME (object);
- GtkFramePriv *priv = frame->priv;
+ GtkFramePrivate *priv = frame->priv;
switch (prop_id)
{
GtkWidget *child)
{
GtkFrame *frame = GTK_FRAME (container);
- GtkFramePriv *priv = frame->priv;
+ GtkFramePrivate *priv = frame->priv;
if (priv->label_widget == child)
gtk_frame_set_label_widget (frame, NULL);
{
GtkBin *bin = GTK_BIN (container);
GtkFrame *frame = GTK_FRAME (container);
- GtkFramePriv *priv = frame->priv;
+ GtkFramePrivate *priv = frame->priv;
GtkWidget *child;
child = gtk_bin_get_child (bin);
G_CONST_RETURN gchar *
gtk_frame_get_label (GtkFrame *frame)
{
- GtkFramePriv *priv;
+ GtkFramePrivate *priv;
g_return_val_if_fail (GTK_IS_FRAME (frame), NULL);
gtk_frame_set_label_widget (GtkFrame *frame,
GtkWidget *label_widget)
{
- GtkFramePriv *priv;
+ GtkFramePrivate *priv;
gboolean need_resize = FALSE;
g_return_if_fail (GTK_IS_FRAME (frame));
gfloat xalign,
gfloat yalign)
{
- GtkFramePriv *priv;
+ GtkFramePrivate *priv;
g_return_if_fail (GTK_IS_FRAME (frame));
gfloat *xalign,
gfloat *yalign)
{
- GtkFramePriv *priv;
+ GtkFramePrivate *priv;
g_return_if_fail (GTK_IS_FRAME (frame));
gtk_frame_set_shadow_type (GtkFrame *frame,
GtkShadowType type)
{
- GtkFramePriv *priv;
+ GtkFramePrivate *priv;
GtkWidget *widget;
g_return_if_fail (GTK_IS_FRAME (frame));
GdkRectangle *area)
{
GtkFrame *frame;
- GtkFramePriv *priv;
+ GtkFramePrivate *priv;
GtkStateType state;
GtkStyle *style;
GdkWindow *window;
GtkAllocation *allocation)
{
GtkFrame *frame = GTK_FRAME (widget);
- GtkFramePriv *priv = frame->priv;
+ GtkFramePrivate *priv = frame->priv;
GtkBin *bin = GTK_BIN (widget);
GtkAllocation new_allocation;
GtkWidget *child;
gtk_frame_real_compute_child_allocation (GtkFrame *frame,
GtkAllocation *child_allocation)
{
- GtkFramePriv *priv = frame->priv;
+ GtkFramePrivate *priv = frame->priv;
GtkWidget *widget = GTK_WIDGET (frame);
GtkAllocation allocation;
GtkStyle *style;
gint *natural_size)
{
GtkFrame *frame = GTK_FRAME (request);
- GtkFramePriv *priv = frame->priv;
+ GtkFramePrivate *priv = frame->priv;
GtkStyle *style;
GtkWidget *widget = GTK_WIDGET (request);
GtkWidget *child;
GtkWidget *widget = GTK_WIDGET (request);
GtkWidget *child;
GtkFrame *frame = GTK_FRAME (widget);
- GtkFramePriv *priv = frame->priv;
+ GtkFramePrivate *priv = frame->priv;
GtkBin *bin = GTK_BIN (widget);
GtkStyle *style;
gint child_min, child_nat, label_width;
#define GTK_IS_FRAME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FRAME))
#define GTK_FRAME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FRAME, GtkFrameClass))
-typedef struct _GtkFrame GtkFrame;
-typedef struct _GtkFramePriv GtkFramePriv;
-typedef struct _GtkFrameClass GtkFrameClass;
+typedef struct _GtkFrame GtkFrame;
+typedef struct _GtkFramePrivate GtkFramePrivate;
+typedef struct _GtkFrameClass GtkFrameClass;
struct _GtkFrame
{
GtkBin bin;
/* <private> */
- GtkFramePriv *priv;
+ GtkFramePrivate *priv;
};
struct _GtkFrameClass
-struct _GtkHandleBoxPriv
+struct _GtkHandleBoxPrivate
{
/* Properties */
GtkPositionType handle_position;
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
- g_type_class_add_private (gobject_class, sizeof (GtkHandleBoxPriv));
+ g_type_class_add_private (gobject_class, sizeof (GtkHandleBoxPrivate));
}
static void
gtk_handle_box_init (GtkHandleBox *handle_box)
{
- GtkHandleBoxPriv *priv;
+ GtkHandleBoxPrivate *priv;
handle_box->priv = G_TYPE_INSTANCE_GET_PRIVATE (handle_box,
GTK_TYPE_HANDLE_BOX,
- GtkHandleBoxPriv);
+ GtkHandleBoxPrivate);
priv = handle_box->priv;
gtk_widget_set_has_window (GTK_WIDGET (handle_box), TRUE);
GParamSpec *pspec)
{
GtkHandleBox *handle_box = GTK_HANDLE_BOX (object);
- GtkHandleBoxPriv *priv = handle_box->priv;
+ GtkHandleBoxPrivate *priv = handle_box->priv;
switch (prop_id)
{
gtk_handle_box_map (GtkWidget *widget)
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
GtkBin *bin = GTK_BIN (widget);
GtkWidget *child;
gtk_handle_box_unmap (GtkWidget *widget)
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
gtk_widget_set_mapped (widget, FALSE);
gtk_handle_box_realize (GtkWidget *widget)
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
GtkWidget *child;
GdkWindowAttr attributes;
gint attributes_mask;
gtk_handle_box_unrealize (GtkWidget *widget)
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
gdk_window_set_user_data (priv->bin_window, NULL);
gdk_window_destroy (priv->bin_window);
GtkStyle *previous_style)
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
if (gtk_widget_get_realized (widget) &&
gtk_widget_get_has_window (widget))
static int
effective_handle_position (GtkHandleBox *hb)
{
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
int handle_position;
if (gtk_widget_get_direction (GTK_WIDGET (hb)) == GTK_TEXT_DIR_LTR)
{
GtkBin *bin = GTK_BIN (widget);
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
GtkRequisition child_requisition;
GtkWidget *child;
gint handle_position;
{
GtkBin *bin = GTK_BIN (widget);
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
GtkRequisition child_requisition;
GtkWidget *child;
gint handle_position;
gtk_handle_box_set_shadow_type (GtkHandleBox *handle_box,
GtkShadowType type)
{
- GtkHandleBoxPriv *priv;
+ GtkHandleBoxPrivate *priv;
g_return_if_fail (GTK_IS_HANDLE_BOX (handle_box));
gtk_handle_box_set_handle_position (GtkHandleBox *handle_box,
GtkPositionType position)
{
- GtkHandleBoxPriv *priv;
+ GtkHandleBoxPrivate *priv;
g_return_if_fail (GTK_IS_HANDLE_BOX (handle_box));
gtk_handle_box_set_snap_edge (GtkHandleBox *handle_box,
GtkPositionType edge)
{
- GtkHandleBoxPriv *priv;
+ GtkHandleBoxPrivate *priv;
g_return_if_fail (GTK_IS_HANDLE_BOX (handle_box));
GdkRectangle *area)
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
GtkBin *bin = GTK_BIN (widget);
GtkWidget *child;
gint width, height;
GdkEventExpose *event)
{
GtkHandleBox *hb;
- GtkHandleBoxPriv *priv;
+ GtkHandleBoxPrivate *priv;
if (gtk_widget_is_drawable (widget))
{
GdkEvent *event,
GtkHandleBox *hb)
{
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
switch (event->type)
{
GdkEventButton *event)
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
gboolean event_handled;
GdkCursor *fleur;
gint handle_position;
GdkEventMotion *event)
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
GtkWidget *child;
gint new_x, new_y;
gint snap_edge;
gtk_handle_box_add (GtkContainer *container,
GtkWidget *widget)
{
- GtkHandleBoxPriv *priv = GTK_HANDLE_BOX (container)->priv;
+ GtkHandleBoxPrivate *priv = GTK_HANDLE_BOX (container)->priv;
gtk_widget_set_parent_window (widget, priv->bin_window);
GTK_CONTAINER_CLASS (gtk_handle_box_parent_class)->add (container, widget);
GdkEventAny *event)
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
if (event->window == priv->float_window)
{
static void
gtk_handle_box_reattach (GtkHandleBox *hb)
{
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
GtkWidget *child;
GtkWidget *widget = GTK_WIDGET (hb);
gtk_handle_box_end_drag (GtkHandleBox *hb,
guint32 time)
{
- GtkHandleBoxPriv *priv = hb->priv;
+ GtkHandleBoxPrivate *priv = hb->priv;
GtkWidget *invisible = gtk_handle_box_get_invisible ();
priv->in_drag = FALSE;
#define GTK_IS_HANDLE_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HANDLE_BOX))
#define GTK_HANDLE_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HANDLE_BOX, GtkHandleBoxClass))
-typedef struct _GtkHandleBox GtkHandleBox;
-typedef struct _GtkHandleBoxPriv GtkHandleBoxPriv;
-typedef struct _GtkHandleBoxClass GtkHandleBoxClass;
+typedef struct _GtkHandleBox GtkHandleBox;
+typedef struct _GtkHandleBoxPrivate GtkHandleBoxPrivate;
+typedef struct _GtkHandleBoxClass GtkHandleBoxClass;
struct _GtkHandleBox
{
GtkBin bin;
/* <private> */
- GtkHandleBoxPriv *priv;
+ GtkHandleBoxPrivate *priv;
};
struct _GtkHandleBoxClass
} DragMode;
/* Private part of the GtkHSV structure */
-struct _GtkHSVPriv
+struct _GtkHSVPrivate
{
/* Color value */
double h;
"move", 1,
G_TYPE_ENUM, GTK_DIR_LEFT);
- g_type_class_add_private (gobject_class, sizeof (GtkHSVPriv));
+ g_type_class_add_private (gobject_class, sizeof (GtkHSVPrivate));
}
/* Object initialization function for the HSV color selector */
static void
gtk_hsv_init (GtkHSV *hsv)
{
- GtkHSVPriv *priv;
+ GtkHSVPrivate *priv;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (hsv, GTK_TYPE_HSV, GtkHSVPriv);
+ priv = G_TYPE_INSTANCE_GET_PRIVATE (hsv, GTK_TYPE_HSV, GtkHSVPrivate);
hsv->priv = priv;
gtk_hsv_map (GtkWidget *widget)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
GTK_WIDGET_CLASS (gtk_hsv_parent_class)->map (widget);
gtk_hsv_unmap (GtkWidget *widget)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
gdk_window_hide (priv->window);
gtk_hsv_realize (GtkWidget *widget)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
GtkAllocation allocation;
GdkWindow *parent_window;
GdkWindowAttr attr;
gtk_hsv_unrealize (GtkWidget *widget)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
gdk_window_set_user_data (priv->window, NULL);
gdk_window_destroy (priv->window);
GtkRequisition *requisition)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
gint focus_width;
gint focus_pad;
GtkAllocation *allocation)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
gtk_widget_set_allocation (widget, allocation);
gint *vx,
gint *vy)
{
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
GtkAllocation allocation;
GtkWidget *widget = GTK_WIDGET (hsv);
gdouble center_x;
gdouble x,
gdouble y)
{
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
GtkAllocation allocation;
GtkWidget *widget = GTK_WIDGET (hsv);
gdouble dx, dy, dist;
set_cross_grab (GtkHSV *hsv,
guint32 time)
{
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
GdkCursor *cursor;
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (hsv)),
GdkEventGrabBroken *event)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
priv->mode = DRAG_NONE;
GdkEventButton *event)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
double x, y;
if (priv->mode != DRAG_NONE || event->button != 1)
GdkEventButton *event)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
DragMode mode;
gdouble x, y;
GdkEventMotion *event)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
GdkModifierType mods;
double x, y;
gint width,
gint height)
{
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
GtkAllocation allocation;
GtkWidget *widget = GTK_WIDGET (hsv);
int xx, yy;
gint width,
gint height)
{
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
GtkWidget *widget = GTK_WIDGET (hsv);
gint hx, hy, sx, sy, vx, vy; /* HSV vertices */
gint x1, y1, r1, g1, b1; /* First vertex in scanline order */
GdkEventExpose *event)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
GtkAllocation allocation;
GdkRectangle rect, dest;
GdkWindow *window;
GtkDirectionType dir)
{
GtkHSV *hsv = GTK_HSV (widget);
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
if (!gtk_widget_has_focus (widget))
{
gdouble s,
gdouble v)
{
- GtkHSVPriv *priv;
+ GtkHSVPrivate *priv;
g_return_if_fail (GTK_IS_HSV (hsv));
g_return_if_fail (h >= 0.0 && h <= 1.0);
double *s,
double *v)
{
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
g_return_if_fail (GTK_IS_HSV (hsv));
gint size,
gint ring_width)
{
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
int same_size;
g_return_if_fail (GTK_IS_HSV (hsv));
gint *size,
gint *ring_width)
{
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
g_return_if_fail (GTK_IS_HSV (hsv));
gboolean
gtk_hsv_is_adjusting (GtkHSV *hsv)
{
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
g_return_val_if_fail (GTK_IS_HSV (hsv), FALSE);
gtk_hsv_move (GtkHSV *hsv,
GtkDirectionType dir)
{
- GtkHSVPriv *priv = hsv->priv;
+ GtkHSVPrivate *priv = hsv->priv;
gdouble hue, sat, val;
gint hx, hy, sx, sy, vx, vy; /* HSV vertices */
gint x, y; /* position in triangle */
#define GTK_HSV_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HSV, GtkHSVClass))
-typedef struct _GtkHSV GtkHSV;
-typedef struct _GtkHSVPriv GtkHSVPriv;
-typedef struct _GtkHSVClass GtkHSVClass;
+typedef struct _GtkHSV GtkHSV;
+typedef struct _GtkHSVPrivate GtkHSVPrivate;
+typedef struct _GtkHSVClass GtkHSVClass;
struct _GtkHSV
{
GtkWidget parent_instance;
/* <private> */
- GtkHSVPriv *priv;
+ GtkHSVPrivate *priv;
};
struct _GtkHSVClass
static GSList *all_icon_factories = NULL;
-struct _GtkIconFactoryPriv
+struct _GtkIconFactoryPrivate
{
GHashTable *icons;
};
static void
gtk_icon_factory_init (GtkIconFactory *factory)
{
- GtkIconFactoryPriv *priv;
+ GtkIconFactoryPrivate *priv;
factory->priv = G_TYPE_INSTANCE_GET_PRIVATE (factory,
GTK_TYPE_ICON_FACTORY,
- GtkIconFactoryPriv);
+ GtkIconFactoryPrivate);
priv = factory->priv;
priv->icons = g_hash_table_new (g_str_hash, g_str_equal);
object_class->finalize = gtk_icon_factory_finalize;
- g_type_class_add_private (klass, sizeof (GtkIconFactoryPriv));
+ g_type_class_add_private (klass, sizeof (GtkIconFactoryPrivate));
}
static void
gtk_icon_factory_finalize (GObject *object)
{
GtkIconFactory *factory = GTK_ICON_FACTORY (object);
- GtkIconFactoryPriv *priv = factory->priv;
+ GtkIconFactoryPrivate *priv = factory->priv;
all_icon_factories = g_slist_remove (all_icon_factories, factory);
const gchar *stock_id,
GtkIconSet *icon_set)
{
- GtkIconFactoryPriv *priv = factory->priv;
+ GtkIconFactoryPrivate *priv = factory->priv;
gpointer old_key = NULL;
gpointer old_value = NULL;
gtk_icon_factory_lookup (GtkIconFactory *factory,
const gchar *stock_id)
{
- GtkIconFactoryPriv *priv;
+ GtkIconFactoryPrivate *priv;
g_return_val_if_fail (GTK_IS_ICON_FACTORY (factory), NULL);
g_return_val_if_fail (stock_id != NULL, NULL);
{
GList *these_ids;
GtkIconFactory *factory = GTK_ICON_FACTORY (tmp_list->data);
- GtkIconFactoryPriv *priv = factory->priv;
+ GtkIconFactoryPrivate *priv = factory->priv;
these_ids = g_hash_table_get_keys (priv->icons);
#define GTK_TYPE_ICON_SET (gtk_icon_set_get_type ())
#define GTK_TYPE_ICON_SOURCE (gtk_icon_source_get_type ())
-typedef struct _GtkIconFactoryPriv GtkIconFactoryPriv;
-typedef struct _GtkIconFactoryClass GtkIconFactoryClass;
+typedef struct _GtkIconFactoryPrivate GtkIconFactoryPrivate;
+typedef struct _GtkIconFactoryClass GtkIconFactoryClass;
struct _GtkIconFactory
{
GObject parent_instance;
/* <private> */
- GtkIconFactoryPriv *priv;
+ GtkIconFactoryPrivate *priv;
};
struct _GtkIconFactoryClass
*/
-struct _GtkImagePriv
+struct _GtkImagePrivate
{
GtkIconSize icon_size; /* Only used with GTK_IMAGE_STOCK, GTK_IMAGE_ICON_SET, GTK_IMAGE_ICON_NAME */
GtkImageType storage_type;
GTK_IMAGE_EMPTY,
GTK_PARAM_READABLE));
- g_type_class_add_private (object_class, sizeof (GtkImagePriv));
+ g_type_class_add_private (object_class, sizeof (GtkImagePrivate));
}
static void
gtk_image_init (GtkImage *image)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
image->priv = G_TYPE_INSTANCE_GET_PRIVATE (image,
GTK_TYPE_IMAGE,
- GtkImagePriv);
+ GtkImagePrivate);
priv = image->priv;
gtk_widget_set_has_window (GTK_WIDGET (image), FALSE);
GParamSpec *pspec)
{
GtkImage *image = GTK_IMAGE (object);
- GtkImagePriv *priv = image->priv;
+ GtkImagePrivate *priv = image->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkImage *image = GTK_IMAGE (object);
- GtkImagePriv *priv = image->priv;
+ GtkImagePrivate *priv = image->priv;
/* The "getter" functions whine if you try to get the wrong
* storage type. This function is instead robust against that,
GdkPixmap *pixmap,
GdkBitmap *mask)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
g_return_if_fail (pixmap == NULL ||
gtk_image_set_from_file (GtkImage *image,
const gchar *filename)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
GdkPixbufAnimation *anim;
g_return_if_fail (GTK_IS_IMAGE (image));
gtk_image_set_from_pixbuf (GtkImage *image,
GdkPixbuf *pixbuf)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
g_return_if_fail (pixbuf == NULL ||
const gchar *stock_id,
GtkIconSize size)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
gchar *new_id;
g_return_if_fail (GTK_IS_IMAGE (image));
GtkIconSet *icon_set,
GtkIconSize size)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
gtk_image_set_from_animation (GtkImage *image,
GdkPixbufAnimation *animation)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
g_return_if_fail (animation == NULL ||
GtkIconSize size)
{
gchar *new_name;
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
GIcon *icon,
GtkIconSize size)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
GdkPixmap **pixmap,
GdkBitmap **mask)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
GdkPixbuf*
gtk_image_get_pixbuf (GtkImage *image)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_val_if_fail (GTK_IS_IMAGE (image), NULL);
gchar **stock_id,
GtkIconSize *size)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
GtkIconSet **icon_set,
GtkIconSize *size)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
GdkPixbufAnimation*
gtk_image_get_animation (GtkImage *image)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_val_if_fail (GTK_IS_IMAGE (image), NULL);
G_CONST_RETURN gchar **icon_name,
GtkIconSize *size)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
GIcon **gicon,
GtkIconSize *size)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
static void
gtk_image_reset_anim_iter (GtkImage *image)
{
- GtkImagePriv *priv = image->priv;
+ GtkImagePrivate *priv = image->priv;
if (priv->storage_type == GTK_IMAGE_ANIMATION)
{
animation_timeout (gpointer data)
{
GtkImage *image = GTK_IMAGE (data);
- GtkImagePriv *priv = image->priv;
+ GtkImagePrivate *priv = image->priv;
int delay;
priv->data.anim.frame_timeout = 0;
static void
icon_theme_changed (GtkImage *image)
{
- GtkImagePriv *priv = image->priv;
+ GtkImagePrivate *priv = image->priv;
if (priv->storage_type == GTK_IMAGE_ICON_NAME)
{
ensure_pixbuf_for_icon_name (GtkImage *image,
GtkStateType state)
{
- GtkImagePriv *priv = image->priv;
+ GtkImagePrivate *priv = image->priv;
GdkScreen *screen;
GtkIconTheme *icon_theme;
GtkSettings *settings;
ensure_pixbuf_for_gicon (GtkImage *image,
GtkStateType state)
{
- GtkImagePriv *priv = image->priv;
+ GtkImagePrivate *priv = image->priv;
GdkScreen *screen;
GtkIconTheme *icon_theme;
GtkSettings *settings;
GdkEventExpose *event)
{
GtkImage *image;
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_val_if_fail (GTK_IS_IMAGE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
static void
gtk_image_reset (GtkImage *image)
{
- GtkImagePriv *priv = image->priv;
+ GtkImagePrivate *priv = image->priv;
g_object_freeze_notify (G_OBJECT (image));
void
gtk_image_clear (GtkImage *image)
{
- GtkImagePriv *priv = image->priv;
+ GtkImagePrivate *priv = image->priv;
priv->need_calc_size = 1;
gtk_image_calc_size (GtkImage *image)
{
GtkWidget *widget = GTK_WIDGET (image);
- GtkImagePriv *priv = image->priv;
+ GtkImagePrivate *priv = image->priv;
GdkPixbuf *pixbuf = NULL;
priv->need_calc_size = 0;
gtk_image_set_pixel_size (GtkImage *image,
gint pixel_size)
{
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
g_return_if_fail (GTK_IS_IMAGE (image));
#define GTK_IMAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IMAGE, GtkImageClass))
-typedef struct _GtkImage GtkImage;
-typedef struct _GtkImagePriv GtkImagePriv;
-typedef struct _GtkImageClass GtkImageClass;
+typedef struct _GtkImage GtkImage;
+typedef struct _GtkImagePrivate GtkImagePrivate;
+typedef struct _GtkImageClass GtkImageClass;
typedef struct _GtkImagePixmapData GtkImagePixmapData;
typedef struct _GtkImageImageData GtkImageImageData;
GtkMisc misc;
/* <private> */
- GtkImagePriv *priv;
+ GtkImagePrivate *priv;
};
struct _GtkImageClass
-struct _GtkImageMenuItemPriv
+struct _GtkImageMenuItemPrivate
{
GtkWidget *image;
TRUE,
GTK_PARAM_READWRITE));
- g_type_class_add_private (object_class, sizeof (GtkImageMenuItemPriv));
+ g_type_class_add_private (object_class, sizeof (GtkImageMenuItemPrivate));
}
static void
gtk_image_menu_item_init (GtkImageMenuItem *image_menu_item)
{
- GtkImageMenuItemPriv *priv;
+ GtkImageMenuItemPrivate *priv;
image_menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (image_menu_item,
GTK_TYPE_IMAGE_MENU_ITEM,
- GtkImageMenuItemPriv);
+ GtkImageMenuItemPrivate);
priv = image_menu_item->priv;
priv->image = NULL;
static void
gtk_image_menu_item_finalize (GObject *object)
{
- GtkImageMenuItemPriv *priv = GTK_IMAGE_MENU_ITEM (object)->priv;
+ GtkImageMenuItemPrivate *priv = GTK_IMAGE_MENU_ITEM (object)->priv;
g_free (priv->label);
priv->label = NULL;
static gboolean
show_image (GtkImageMenuItem *image_menu_item)
{
- GtkImageMenuItemPriv *priv = image_menu_item->priv;
+ GtkImageMenuItemPrivate *priv = image_menu_item->priv;
GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (image_menu_item));
gboolean show;
gtk_image_menu_item_map (GtkWidget *widget)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
- GtkImageMenuItemPriv *priv = image_menu_item->priv;
+ GtkImageMenuItemPrivate *priv = image_menu_item->priv;
GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->map (widget);
gtk_image_menu_item_destroy (GtkObject *object)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (object);
- GtkImageMenuItemPriv *priv = image_menu_item->priv;
+ GtkImageMenuItemPrivate *priv = image_menu_item->priv;
if (priv->image)
gtk_container_remove (GTK_CONTAINER (image_menu_item),
gint *requisition)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (menu_item);
- GtkImageMenuItemPriv *priv = image_menu_item->priv;
+ GtkImageMenuItemPrivate *priv = image_menu_item->priv;
GtkPackDirection pack_dir;
GtkWidget *parent;
GtkWidget *widget = GTK_WIDGET (menu_item);
static void
gtk_image_menu_item_recalculate (GtkImageMenuItem *image_menu_item)
{
- GtkImageMenuItemPriv *priv = image_menu_item->priv;
+ GtkImageMenuItemPrivate *priv = image_menu_item->priv;
GtkStockItem stock_item;
GtkWidget *image;
const gchar *resolved_label = priv->label;
gtk_image_menu_item_set_label (GtkMenuItem *menu_item,
const gchar *label)
{
- GtkImageMenuItemPriv *priv = GTK_IMAGE_MENU_ITEM (menu_item)->priv;
+ GtkImageMenuItemPrivate *priv = GTK_IMAGE_MENU_ITEM (menu_item)->priv;
if (priv->label != label)
{
static G_CONST_RETURN gchar *
gtk_image_menu_item_get_label (GtkMenuItem *menu_item)
{
- GtkImageMenuItemPriv *priv = GTK_IMAGE_MENU_ITEM (menu_item)->priv;
+ GtkImageMenuItemPrivate *priv = GTK_IMAGE_MENU_ITEM (menu_item)->priv;
return priv->label;
}
GtkRequisition *requisition)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
- GtkImageMenuItemPriv *priv = image_menu_item->priv;
+ GtkImageMenuItemPrivate *priv = image_menu_item->priv;
gint child_width = 0;
gint child_height = 0;
GtkPackDirection pack_dir;
GtkAllocation *allocation)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
- GtkImageMenuItemPriv *priv = image_menu_item->priv;
+ GtkImageMenuItemPrivate *priv = image_menu_item->priv;
GtkAllocation widget_allocation;
GtkPackDirection pack_dir;
GtkWidget *parent;
gpointer callback_data)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (container);
- GtkImageMenuItemPriv *priv = image_menu_item->priv;
+ GtkImageMenuItemPrivate *priv = image_menu_item->priv;
GTK_CONTAINER_CLASS (gtk_image_menu_item_parent_class)->forall (container,
include_internals,
gtk_image_menu_item_set_use_stock (GtkImageMenuItem *image_menu_item,
gboolean use_stock)
{
- GtkImageMenuItemPriv *priv;
+ GtkImageMenuItemPrivate *priv;
g_return_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item));
gtk_image_menu_item_set_always_show_image (GtkImageMenuItem *image_menu_item,
gboolean always_show)
{
- GtkImageMenuItemPriv *priv;
+ GtkImageMenuItemPrivate *priv;
g_return_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item));
gtk_image_menu_item_set_accel_group (GtkImageMenuItem *image_menu_item,
GtkAccelGroup *accel_group)
{
- GtkImageMenuItemPriv *priv;
+ GtkImageMenuItemPrivate *priv;
GtkStockItem stock_item;
/* Silent return for the constructor */
gtk_image_menu_item_set_image (GtkImageMenuItem *image_menu_item,
GtkWidget *image)
{
- GtkImageMenuItemPriv *priv;
+ GtkImageMenuItemPrivate *priv;
g_return_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item));
GtkWidget *child)
{
GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (container);
- GtkImageMenuItemPriv *priv = image_menu_item->priv;
+ GtkImageMenuItemPrivate *priv = image_menu_item->priv;
if (child == priv->image)
{
static void
show_image_change_notify (GtkImageMenuItem *image_menu_item)
{
- GtkImageMenuItemPriv *priv = image_menu_item->priv;
+ GtkImageMenuItemPrivate *priv = image_menu_item->priv;
if (priv->image)
{
#define GTK_IMAGE_MENU_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IMAGE_MENU_ITEM, GtkImageMenuItemClass))
-typedef struct _GtkImageMenuItem GtkImageMenuItem;
-typedef struct _GtkImageMenuItemPriv GtkImageMenuItemPriv;
-typedef struct _GtkImageMenuItemClass GtkImageMenuItemClass;
+typedef struct _GtkImageMenuItem GtkImageMenuItem;
+typedef struct _GtkImageMenuItemPrivate GtkImageMenuItemPrivate;
+typedef struct _GtkImageMenuItemClass GtkImageMenuItemClass;
struct _GtkImageMenuItem
{
GtkMenuItem menu_item;
/*< private >*/
- GtkImageMenuItemPriv *priv;
+ GtkImageMenuItemPrivate *priv;
};
struct _GtkImageMenuItemClass
typedef struct _GtkComposeTable GtkComposeTable;
typedef struct _GtkComposeTableCompact GtkComposeTableCompact;
-struct _GtkIMContextSimplePriv
+struct _GtkIMContextSimplePrivate
{
GSList *tables;
im_context_class->get_preedit_string = gtk_im_context_simple_get_preedit_string;
gobject_class->finalize = gtk_im_context_simple_finalize;
- g_type_class_add_private (class, sizeof (GtkIMContextSimplePriv));
+ g_type_class_add_private (class, sizeof (GtkIMContextSimplePrivate));
}
static void
{
im_context_simple->priv = G_TYPE_INSTANCE_GET_PRIVATE (im_context_simple,
GTK_TYPE_IM_CONTEXT_SIMPLE,
- GtkIMContextSimplePriv);
+ GtkIMContextSimplePrivate);
}
static void
gtk_im_context_simple_finalize (GObject *obj)
{
GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (obj);
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
if (priv->tables)
{
gunichar ch)
{
GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
gchar buf[10];
gint len;
const GtkComposeTable *table,
gint n_compose)
{
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
gint row_stride = table->max_seq_len + 2;
guint16 *seq;
check_win32_special_cases (GtkIMContextSimple *context_simple,
gint n_compose)
{
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
if (n_compose == 2 &&
priv->compose_buffer[1] == GDK_space)
{
gint n_compose,
guint value)
{
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
/* On Windows user expectation is that typing two dead accents will input
* two corresponding spacing accents.
const GtkComposeTableCompact *table,
gint n_compose)
{
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
gint row_stride;
guint16 *seq_index;
guint16 *seq;
gint n_compose)
{
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
gint i;
gunichar combination_buffer[GTK_MAX_COMPOSE_LEN];
gchar *combination_utf8, *nfc;
check_hex (GtkIMContextSimple *context_simple,
gint n_compose)
{
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
/* See if this is a hex sequence, return TRUE if so */
gint i;
GString *str;
gint n_compose,
GdkEventKey *event)
{
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
GtkIMContext *context;
gunichar ch;
GdkEventKey *event)
{
GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
GSList *tmp_list;
int n_compose = 0;
gboolean have_hex_mods;
gtk_im_context_simple_reset (GtkIMContext *context)
{
GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
priv->compose_buffer[0] = 0;
gint *cursor_pos)
{
GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
char outbuf[37]; /* up to 6 hex digits */
int len = 0;
gint max_seq_len,
gint n_seqs)
{
- GtkIMContextSimplePriv *priv = context_simple->priv;
+ GtkIMContextSimplePrivate *priv = context_simple->priv;
GtkComposeTable *table;
g_return_if_fail (GTK_IS_IM_CONTEXT_SIMPLE (context_simple));
#define GTK_IM_CONTEXT_SIMPLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IM_CONTEXT_SIMPLE, GtkIMContextSimpleClass))
-typedef struct _GtkIMContextSimple GtkIMContextSimple;
-typedef struct _GtkIMContextSimplePriv GtkIMContextSimplePriv;
-typedef struct _GtkIMContextSimpleClass GtkIMContextSimpleClass;
+typedef struct _GtkIMContextSimple GtkIMContextSimple;
+typedef struct _GtkIMContextSimplePrivate GtkIMContextSimplePrivate;
+typedef struct _GtkIMContextSimpleClass GtkIMContextSimpleClass;
#define GTK_MAX_COMPOSE_LEN 7
GtkIMContext object;
/* <private> */
- GtkIMContextSimplePriv *priv;
+ GtkIMContextSimplePrivate *priv;
};
struct _GtkIMContextSimpleClass
#include "gtkprivate.h"
#include "gtkintl.h"
-struct _GtkInvisiblePriv
+struct _GtkInvisiblePrivate
{
GdkScreen *screen;
gboolean has_user_ref_count;
GDK_TYPE_SCREEN,
GTK_PARAM_READWRITE));
- g_type_class_add_private (class, sizeof (GtkInvisiblePriv));
+ g_type_class_add_private (class, sizeof (GtkInvisiblePrivate));
}
static void
gtk_invisible_init (GtkInvisible *invisible)
{
- GtkInvisiblePriv *priv;
+ GtkInvisiblePrivate *priv;
GdkColormap *colormap;
invisible->priv = G_TYPE_INSTANCE_GET_PRIVATE (invisible,
GTK_TYPE_INVISIBLE,
- GtkInvisiblePriv);
+ GtkInvisiblePrivate);
priv = invisible->priv;
gtk_widget_set_has_window (GTK_WIDGET (invisible), TRUE);
gtk_invisible_destroy (GtkObject *object)
{
GtkInvisible *invisible = GTK_INVISIBLE (object);
- GtkInvisiblePriv *priv = invisible->priv;
+ GtkInvisiblePrivate *priv = invisible->priv;
if (priv->has_user_ref_count)
{
gtk_invisible_set_screen (GtkInvisible *invisible,
GdkScreen *screen)
{
- GtkInvisiblePriv *priv;
+ GtkInvisiblePrivate *priv;
GtkWidget *widget;
GdkScreen *previous_screen;
gboolean was_realized;
GParamSpec *pspec)
{
GtkInvisible *invisible = GTK_INVISIBLE (object);
- GtkInvisiblePriv *priv = invisible->priv;
+ GtkInvisiblePrivate *priv = invisible->priv;
switch (prop_id)
{
#define GTK_INVISIBLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_INVISIBLE, GtkInvisibleClass))
-typedef struct _GtkInvisible GtkInvisible;
-typedef struct _GtkInvisiblePriv GtkInvisiblePriv;
-typedef struct _GtkInvisibleClass GtkInvisibleClass;
+typedef struct _GtkInvisible GtkInvisible;
+typedef struct _GtkInvisiblePrivate GtkInvisiblePrivate;
+typedef struct _GtkInvisibleClass GtkInvisibleClass;
struct _GtkInvisible
{
GtkWidget widget;
/* <private> */
- GtkInvisiblePriv *priv;
+ GtkInvisiblePrivate *priv;
};
struct _GtkInvisibleClass
#include "gtkprivate.h"
-struct _GtkLabelPriv
+struct _GtkLabelPrivate
{
GtkLabelSelectionInfo *select_info;
GtkWidget *mnemonic_widget;
TRUE,
GTK_PARAM_READWRITE));
- g_type_class_add_private (class, sizeof (GtkLabelPriv));
+ g_type_class_add_private (class, sizeof (GtkLabelPrivate));
}
static void
GParamSpec *pspec)
{
GtkLabel *label = GTK_LABEL (object);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
switch (prop_id)
{
static void
gtk_label_init (GtkLabel *label)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
label->priv = G_TYPE_INSTANCE_GET_PRIVATE (label,
GTK_TYPE_LABEL,
- GtkLabelPriv);
+ GtkLabelPrivate);
priv = label->priv;
gtk_widget_set_has_window (GTK_WIDGET (label), FALSE);
gboolean group_cycling)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkWidget *parent;
if (priv->mnemonic_widget)
gtk_label_setup_mnemonic (GtkLabel *label,
guint last_key)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkWidget *widget = GTK_WIDGET (label);
GtkWidget *toplevel;
GtkWidget *mnemonic_menu;
GtkWidget *old_toplevel)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gtk_label_setup_mnemonic (label, priv->mnemonic_keyval);
}
gboolean mnemonics_visible)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
mnemonics_visible = mnemonics_visible != FALSE;
GObject *where_the_object_was)
{
GtkLabel *label = data;
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
priv->mnemonic_widget = NULL;
g_object_notify (G_OBJECT (label), "mnemonic-widget");
gtk_label_set_mnemonic_widget (GtkLabel *label,
GtkWidget *widget)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gtk_label_set_text_internal (GtkLabel *label,
gchar *str)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
g_free (priv->text);
gtk_label_set_label_internal (GtkLabel *label,
gchar *str)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
g_free (priv->label);
gtk_label_set_use_markup_internal (GtkLabel *label,
gboolean val)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
val = val != FALSE;
if (priv->use_markup != val)
gtk_label_set_use_underline_internal (GtkLabel *label,
gboolean val)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
val = val != FALSE;
if (priv->use_underline != val)
static void
gtk_label_compose_effective_attrs (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
PangoAttrIterator *iter;
PangoAttribute *attr;
GSList *iter_attrs, *l;
gtk_label_set_attributes_internal (GtkLabel *label,
PangoAttrList *attrs)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (attrs)
pango_attr_list_ref (attrs);
static void
gtk_label_recalculate (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
guint keyval = priv->mnemonic_keyval;
if (priv->use_markup)
gpointer user_data,
GError **error)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
UriParserData *pdata = user_data;
if (strcmp (element_name, "a") == 0)
static void
gtk_label_ensure_has_tooltip (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GList *l;
gboolean has_tooltip = FALSE;
const gchar *str,
gboolean with_uline)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gchar *text = NULL;
GError *error = NULL;
PangoAttrList *attrs = NULL;
gtk_label_set_markup (GtkLabel *label,
const gchar *str)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gtk_label_set_markup_with_mnemonic (GtkLabel *label,
const gchar *str)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gtk_label_pattern_to_attrs (GtkLabel *label,
const gchar *pattern)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
const char *start;
const char *p = priv->text;
const char *q = pattern;
const gchar *pattern,
gboolean is_mnemonic)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
PangoAttrList *attrs;
gboolean enable_mnemonics;
gboolean auto_mnemonics;
gtk_label_set_pattern (GtkLabel *label,
const gchar *pattern)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
g_return_if_fail (GTK_IS_LABEL (label));
gtk_label_set_justify (GtkLabel *label,
GtkJustification jtype)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
g_return_if_fail (jtype >= GTK_JUSTIFY_LEFT && jtype <= GTK_JUSTIFY_FILL);
gtk_label_set_ellipsize (GtkLabel *label,
PangoEllipsizeMode mode)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
g_return_if_fail (mode >= PANGO_ELLIPSIZE_NONE && mode <= PANGO_ELLIPSIZE_END);
gtk_label_set_width_chars (GtkLabel *label,
gint n_chars)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gtk_label_set_max_width_chars (GtkLabel *label,
gint n_chars)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gtk_label_set_line_wrap (GtkLabel *label,
gboolean wrap)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gtk_label_set_line_wrap_mode (GtkLabel *label,
PangoWrapMode wrap_mode)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gtk_label_finalize (GObject *object)
{
GtkLabel *label = GTK_LABEL (object);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
g_free (priv->label);
g_free (priv->text);
static void
gtk_label_clear_layout (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->layout)
{
gint *natural)
{
GtkWidgetAuxInfo *aux_info;
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
PangoLayout *layout;
PangoContext *context;
PangoFontMetrics *metrics;
static void
gtk_label_invalidate_wrap_width (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
priv->wrap_width = -1;
}
static gint
get_label_wrap_width (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->wrap_width < 0)
{
static void
gtk_label_ensure_layout (GtkLabel *label, gboolean guess_wrap_width)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkWidget *widget;
PangoRectangle logical_rect;
gboolean rtl;
gint *minimum_size,
gint *natural_size)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
PangoLayout *layout;
GtkWidgetAuxInfo *aux_info =
_gtk_widget_get_aux_info (GTK_WIDGET (label), FALSE);
gint *natural_size)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
PangoRectangle required_rect;
PangoRectangle natural_rect;
gint xpad, ypad;
gint *natural_width)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->wrap && (priv->angle == 90 || priv->angle == 270))
{
gint *natural_height)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->wrap && (priv->angle == 0 || priv->angle == 180 || priv->angle == 360))
{
GtkAllocation *allocation)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GTK_WIDGET_CLASS (gtk_label_parent_class)->size_allocate (widget, allocation);
static void
gtk_label_update_cursor (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkWidget *widget;
if (!priv->select_info)
GtkStateType prev_state)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->select_info)
{
GtkTextDirection previous_dir)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->layout)
pango_layout_context_changed (priv->layout);
GtkAllocation allocation;
GtkMisc *misc;
GtkWidget *widget;
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
gint req_width, x, y;
gint req_height;
gint xpad, ypad;
static PangoDirection
get_cursor_direction (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GSList *l;
g_assert (priv->select_info);
static void
gtk_label_draw_cursor (GtkLabel *label, gint xoffset, gint yoffset)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkWidget *widget;
if (priv->select_info == NULL)
static GtkLabelLink *
gtk_label_get_focus_link (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkLabelSelectionInfo *info = priv->select_info;
GList *l;
GdkEventExpose *event)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkLabelSelectionInfo *info = priv->select_info;
GtkStyle *style;
GdkWindow *window;
gtk_label_set_uline_text_internal (GtkLabel *label,
const gchar *str)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
guint accel_key = GDK_VoidSymbol;
gchar *new_str;
gchar *pattern;
gtk_label_realize (GtkWidget *widget)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GTK_WIDGET_CLASS (gtk_label_parent_class)->realize (widget);
gtk_label_unrealize (GtkWidget *widget)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->select_info)
gtk_label_destroy_window (label);
gtk_label_map (GtkWidget *widget)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GTK_WIDGET_CLASS (gtk_label_parent_class)->map (widget);
gtk_label_unmap (GtkWidget *widget)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->select_info)
gdk_window_hide (priv->select_info->window);
gint y,
gint *index)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gint trailing = 0;
const gchar *cluster;
const gchar *cluster_end;
static void
gtk_label_select_word (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gint min, max;
gint start_index = gtk_label_move_backward_word (label, priv->select_info->selection_end);
gtk_label_grab_focus (GtkWidget *widget)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gboolean select_on_focus;
GtkLabelLink *link;
GtkDirectionType direction)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkLabelSelectionInfo *info = priv->select_info;
GtkLabelLink *focus_link;
GList *l;
GdkEventButton *event)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkLabelSelectionInfo *info = priv->select_info;
gint index = 0;
gint min, max;
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkLabelSelectionInfo *info = priv->select_info;
gint index;
static void
connect_mnemonics_visible_notify (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkWidget *toplevel;
gboolean connected;
gpointer data)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GdkPixmap *pixmap = NULL;
g_signal_handlers_disconnect_by_func (widget, drag_begin_cb, NULL);
GdkEventMotion *event)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkLabelSelectionInfo *info = priv->select_info;
gint index;
GdkEventCrossing *event)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->select_info)
{
static void
gtk_label_create_window (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkAllocation allocation;
GtkWidget *widget;
GdkWindowAttr attributes;
static void
gtk_label_destroy_window (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
g_assert (priv->select_info);
static void
gtk_label_ensure_select_info (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->select_info == NULL)
{
static void
gtk_label_clear_select_info (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->select_info == NULL)
return;
gtk_label_set_selectable (GtkLabel *label,
gboolean setting)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
gboolean old_setting;
g_return_if_fail (GTK_IS_LABEL (label));
gboolean
gtk_label_get_selectable (GtkLabel *label)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
gtk_label_set_angle (GtkLabel *label,
gdouble angle)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gtk_label_set_selection_text (GtkLabel *label,
GtkSelectionData *selection_data)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if ((priv->select_info->selection_anchor !=
priv->select_info->selection_end) &&
gpointer user_data_or_owner)
{
GtkLabel *label;
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
label = GTK_LABEL (user_data_or_owner);
priv = label->priv;
gint anchor_index,
gint end_index)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gint start_offset,
gint end_offset)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gint *start,
gint *end)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
PangoLayout*
gtk_label_get_layout (GtkLabel *label)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
gtk_label_set_single_line_mode (GtkLabel *label,
gboolean single_line_mode)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
gint *x,
gint *y)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (label)));
PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
PangoDirection cursor_direction = get_cursor_direction (label);
gint start,
gint count)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gint offset = g_utf8_pointer_to_offset (priv->text,
priv->text + start);
gint start,
gint count)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gint index;
index = start;
gtk_label_move_forward_word (GtkLabel *label,
gint start)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gint new_pos = g_utf8_pointer_to_offset (priv->text,
priv->text + start);
gint length;
gtk_label_move_backward_word (GtkLabel *label,
gint start)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gint new_pos = g_utf8_pointer_to_offset (priv->text,
priv->text + start);
gint count,
gboolean extend_selection)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gint old_pos;
gint new_pos;
static void
gtk_label_copy_clipboard (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->text && priv->select_info)
{
static void
gtk_label_select_all (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gtk_label_select_region_index (label, 0, strlen (priv->text));
}
GtkMenu *menu)
{
GtkLabel *label = GTK_LABEL (attach_widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (priv->select_info)
priv->select_info->popup_menu = NULL;
gtk_label_do_popup (GtkLabel *label,
GdkEventButton *event)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkWidget *menuitem;
GtkWidget *menu;
GtkWidget *image;
static void
gtk_label_clear_links (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
if (!priv->select_info)
return;
static void
gtk_label_rescan_links (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
PangoLayout *layout = priv->layout;
PangoAttrList *attlist;
PangoAttrIterator *iter;
emit_activate_link (GtkLabel *label,
GtkLabelLink *link)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
gboolean handled;
g_signal_emit (label, signals[ACTIVATE_LINK], 0, link->uri, &handled);
static GtkLabelLink *
gtk_label_get_current_link (GtkLabel *label)
{
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkLabelLink *link;
if (!priv->select_info)
gtk_label_set_track_visited_links (GtkLabel *label,
gboolean track_links)
{
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
g_return_if_fail (GTK_IS_LABEL (label));
GtkTooltip *tooltip)
{
GtkLabel *label = GTK_LABEL (widget);
- GtkLabelPriv *priv = label->priv;
+ GtkLabelPrivate *priv = label->priv;
GtkLabelSelectionInfo *info = priv->select_info;
gint index = -1;
GList *l;
#define GTK_LABEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LABEL, GtkLabelClass))
-typedef struct _GtkLabel GtkLabel;
-typedef struct _GtkLabelPriv GtkLabelPriv;
-typedef struct _GtkLabelClass GtkLabelClass;
+typedef struct _GtkLabel GtkLabel;
+typedef struct _GtkLabelPrivate GtkLabelPrivate;
+typedef struct _GtkLabelClass GtkLabelClass;
typedef struct _GtkLabelSelectionInfo GtkLabelSelectionInfo;
GtkMisc misc;
/*< private >*/
- GtkLabelPriv *priv;
+ GtkLabelPrivate *priv;
};
struct _GtkLabelClass
typedef struct _GtkLayoutChild GtkLayoutChild;
-struct _GtkLayoutPriv
+struct _GtkLayoutPrivate
{
/* Properties */
guint width;
GtkAdjustment *hadj,
GtkAdjustment *vadj)
{
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
gboolean need_adjust = FALSE;
if (hadj)
gtk_layout_finalize (GObject *object)
{
GtkLayout *layout = GTK_LAYOUT (object);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
g_object_unref (priv->hadjustment);
g_object_unref (priv->vadjustment);
gtk_layout_set_hadjustment (GtkLayout *layout,
GtkAdjustment *adjustment)
{
- GtkLayoutPriv *priv;
+ GtkLayoutPrivate *priv;
g_return_if_fail (GTK_IS_LAYOUT (layout));
gtk_layout_set_vadjustment (GtkLayout *layout,
GtkAdjustment *adjustment)
{
- GtkLayoutPriv *priv;
+ GtkLayoutPrivate *priv;
g_return_if_fail (GTK_IS_LAYOUT (layout));
get_child (GtkLayout *layout,
GtkWidget *widget)
{
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
GList *children;
children = priv->children;
gint x,
gint y)
{
- GtkLayoutPriv *priv;
+ GtkLayoutPrivate *priv;
GtkLayoutChild *child;
g_return_if_fail (GTK_IS_LAYOUT (layout));
guint width,
guint height)
{
- GtkLayoutPriv *priv;
+ GtkLayoutPrivate *priv;
GtkWidget *widget;
g_return_if_fail (GTK_IS_LAYOUT (layout));
guint *width,
guint *height)
{
- GtkLayoutPriv *priv;
+ GtkLayoutPrivate *priv;
g_return_if_fail (GTK_IS_LAYOUT (layout));
GTK_TYPE_ADJUSTMENT,
GTK_TYPE_ADJUSTMENT);
- g_type_class_add_private (class, sizeof (GtkLayoutPriv));
+ g_type_class_add_private (class, sizeof (GtkLayoutPrivate));
}
static void
GParamSpec *pspec)
{
GtkLayout *layout = GTK_LAYOUT (object);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkLayout *layout = GTK_LAYOUT (object);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
switch (prop_id)
{
static void
gtk_layout_init (GtkLayout *layout)
{
- GtkLayoutPriv *priv;
+ GtkLayoutPrivate *priv;
layout->priv = G_TYPE_INSTANCE_GET_PRIVATE (layout,
GTK_TYPE_LAYOUT,
- GtkLayoutPriv);
+ GtkLayoutPrivate);
priv = layout->priv;
priv->children = NULL;
guint n_properties,
GObjectConstructParam *properties)
{
- GtkLayoutPriv *priv;
+ GtkLayoutPrivate *priv;
GtkLayout *layout;
GObject *object;
GtkAdjustment *hadj, *vadj;
gtk_layout_realize (GtkWidget *widget)
{
GtkLayout *layout = GTK_LAYOUT (widget);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
GtkAllocation allocation;
GdkWindow *window;
GdkWindowAttr attributes;
gtk_layout_style_set (GtkWidget *widget,
GtkStyle *old_style)
{
- GtkLayoutPriv *priv;
+ GtkLayoutPrivate *priv;
GTK_WIDGET_CLASS (gtk_layout_parent_class)->style_set (widget, old_style);
gtk_layout_map (GtkWidget *widget)
{
GtkLayout *layout = GTK_LAYOUT (widget);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
GList *tmp_list;
gtk_widget_set_mapped (widget, TRUE);
gtk_layout_unrealize (GtkWidget *widget)
{
GtkLayout *layout = GTK_LAYOUT (widget);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
gdk_window_set_user_data (priv->bin_window, NULL);
gdk_window_destroy (priv->bin_window);
GtkRequisition *requisition)
{
GtkLayout *layout = GTK_LAYOUT (widget);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
GList *tmp_list;
requisition->width = 0;
GtkAllocation *allocation)
{
GtkLayout *layout = GTK_LAYOUT (widget);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
GList *tmp_list;
gtk_widget_set_allocation (widget, allocation);
GdkEventExpose *event)
{
GtkLayout *layout = GTK_LAYOUT (widget);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
if (event->window != priv->bin_window)
return FALSE;
GtkWidget *widget)
{
GtkLayout *layout = GTK_LAYOUT (container);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
GList *tmp_list;
GtkLayoutChild *child = NULL;
gpointer callback_data)
{
GtkLayout *layout = GTK_LAYOUT (container);
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
GtkLayoutChild *child;
GList *tmp_list;
gtk_layout_adjustment_changed (GtkAdjustment *adjustment,
GtkLayout *layout)
{
- GtkLayoutPriv *priv = layout->priv;
+ GtkLayoutPrivate *priv = layout->priv;
if (priv->freeze_count)
return;
#define GTK_LAYOUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LAYOUT, GtkLayoutClass))
-typedef struct _GtkLayout GtkLayout;
-typedef struct _GtkLayoutPriv GtkLayoutPriv;
-typedef struct _GtkLayoutClass GtkLayoutClass;
+typedef struct _GtkLayout GtkLayout;
+typedef struct _GtkLayoutPrivate GtkLayoutPrivate;
+typedef struct _GtkLayoutClass GtkLayoutClass;
struct _GtkLayout
{
GtkContainer container;
/* <private> */
- GtkLayoutPriv *priv;
+ GtkLayoutPrivate *priv;
};
struct _GtkLayoutClass
#include "gtkbuilderprivate.h"
-struct _GtkListStorePriv
+struct _GtkListStorePrivate
{
GtkSortType order;
GtkTreeIterCompareFunc default_sort_func;
object_class->finalize = gtk_list_store_finalize;
- g_type_class_add_private (class, sizeof (GtkListStorePriv));
+ g_type_class_add_private (class, sizeof (GtkListStorePrivate));
}
static void
static void
gtk_list_store_init (GtkListStore *list_store)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
list_store->priv = G_TYPE_INSTANCE_GET_PRIVATE (list_store,
GTK_TYPE_LIST_STORE,
- GtkListStorePriv);
+ GtkListStorePrivate);
priv = list_store->priv;
priv->seq = g_sequence_new (NULL);
gint n_columns,
GType *types)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
gint i;
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
gtk_list_store_set_n_columns (GtkListStore *list_store,
gint n_columns)
{
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
int i;
if (priv->n_columns == n_columns)
gint column,
GType type)
{
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
if (!_gtk_tree_data_list_check_type (type))
{
gtk_list_store_finalize (GObject *object)
{
GtkListStore *list_store = GTK_LIST_STORE (object);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
g_sequence_foreach (priv->seq,
(GFunc) _gtk_tree_data_list_free, priv->column_headers);
gtk_list_store_get_n_columns (GtkTreeModel *tree_model)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
priv->columns_dirty = TRUE;
gint index)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
g_return_val_if_fail (index < priv->n_columns, G_TYPE_INVALID);
GtkTreePath *path)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
GSequence *seq;
gint i;
GtkTreeIter *iter)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
GtkTreePath *path;
g_return_val_if_fail (iter->stamp == priv->stamp, NULL);
GValue *value)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
GtkTreeDataList *list;
gint tmp_column = column;
GtkTreeIter *iter)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
gboolean retval;
g_return_val_if_fail (priv->stamp == iter->stamp, FALSE);
GtkTreeIter *parent)
{
GtkListStore *list_store = (GtkListStore *) tree_model;
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
/* this is a list, nodes have no children */
if (parent)
GtkTreeIter *iter)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
if (iter == NULL)
return g_sequence_get_length (priv->seq);
gint n)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
GSequenceIter *child;
iter->stamp = 0;
GValue *value,
gboolean sort)
{
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
GtkTreeDataList *list;
GtkTreeDataList *prev;
gint old_column = column;
gint column,
GValue *value)
{
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
g_return_if_fail (VALID_ITER (iter, list_store));
static GtkTreeIterCompareFunc
gtk_list_store_get_compare_func (GtkListStore *list_store)
{
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
GtkTreeIterCompareFunc func = NULL;
if (GTK_LIST_STORE_IS_SORTED (list_store))
GValue *values,
gint n_values)
{
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
gint i;
GtkTreeIterCompareFunc func = NULL;
gboolean *maybe_need_sort,
va_list var_args)
{
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
gint column;
GtkTreeIterCompareFunc func = NULL;
GValue *values,
gint n_values)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
gboolean emit_signal = FALSE;
gboolean maybe_need_sort = FALSE;
GtkTreeIter *iter,
va_list var_args)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
gboolean emit_signal = FALSE;
gboolean maybe_need_sort = FALSE;
gtk_list_store_remove (GtkListStore *list_store,
GtkTreeIter *iter)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
GtkTreePath *path;
GSequenceIter *ptr, *next;
GtkTreeIter *iter,
gint position)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
GtkTreePath *path;
GSequence *seq;
GSequenceIter *ptr;
GtkTreeIter *iter,
GtkTreeIter *sibling)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
GSequenceIter *after;
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
GtkTreeIter *iter,
GtkTreeIter *sibling)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
GSequenceIter *after;
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
gtk_list_store_append (GtkListStore *list_store,
GtkTreeIter *iter)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
g_return_if_fail (iter != NULL);
static void
gtk_list_store_increment_stamp (GtkListStore *list_store)
{
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
do
{
void
gtk_list_store_clear (GtkListStore *list_store)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
GtkTreeIter iter;
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
gtk_list_store_iter_is_valid (GtkListStore *list_store,
GtkTreeIter *iter)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
{
GtkTreeModel *tree_model = GTK_TREE_MODEL (drag_dest);
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
GtkTreeModel *src_model = NULL;
GtkTreePath *src_path = NULL;
gboolean retval = FALSE;
gtk_list_store_reorder (GtkListStore *store,
gint *new_order)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
gint i;
GtkTreePath *path;
GHashTable *new_positions;
GtkTreeIter *a,
GtkTreeIter *b)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
GHashTable *old_positions;
gint *order;
GtkTreePath *path;
GtkTreeIter *iter,
gint new_pos)
{
- GtkListStorePriv *priv = store->priv;
+ GtkListStorePrivate *priv = store->priv;
GHashTable *old_positions;
GtkTreePath *path;
gint *order;
gpointer user_data)
{
GtkListStore *list_store = user_data;
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
GtkTreeIter iter_a;
GtkTreeIter iter_b;
gint retval;
static void
gtk_list_store_sort (GtkListStore *list_store)
{
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
gint *new_order;
GtkTreePath *path;
GHashTable *old_positions;
gint column)
{
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
GtkTreePath *path;
path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter);
GtkSortType *order)
{
GtkListStore *list_store = GTK_LIST_STORE (sortable);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
if (sort_column_id)
* sort_column_id = priv->sort_column_id;
GtkSortType order)
{
GtkListStore *list_store = GTK_LIST_STORE (sortable);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
if ((priv->sort_column_id == sort_column_id) &&
(priv->order == order))
GDestroyNotify destroy)
{
GtkListStore *list_store = GTK_LIST_STORE (sortable);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
priv->sort_list = _gtk_tree_data_list_set_header (priv->sort_list,
sort_column_id,
GDestroyNotify destroy)
{
GtkListStore *list_store = GTK_LIST_STORE (sortable);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
if (priv->default_sort_destroy)
{
gtk_list_store_has_default_sort_func (GtkTreeSortable *sortable)
{
GtkListStore *list_store = GTK_LIST_STORE (sortable);
- GtkListStorePriv *priv = list_store->priv;
+ GtkListStorePrivate *priv = list_store->priv;
return (priv->default_sort_func != NULL);
}
gint position,
...)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
GtkTreePath *path;
GSequence *seq;
GSequenceIter *ptr;
GValue *values,
gint n_values)
{
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
GtkTreePath *path;
GSequence *seq;
GSequenceIter *ptr;
#define GTK_IS_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LIST_STORE))
#define GTK_LIST_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LIST_STORE, GtkListStoreClass))
-typedef struct _GtkListStore GtkListStore;
-typedef struct _GtkListStorePriv GtkListStorePriv;
-typedef struct _GtkListStoreClass GtkListStoreClass;
+typedef struct _GtkListStore GtkListStore;
+typedef struct _GtkListStorePrivate GtkListStorePrivate;
+typedef struct _GtkListStoreClass GtkListStoreClass;
struct _GtkListStore
{
GObject parent;
/*< private >*/
- GtkListStorePriv *priv;
+ GtkListStorePrivate *priv;
};
struct _GtkListStoreClass
* </refsect2>
*/
-struct _GtkMessageDialogPriv
+struct _GtkMessageDialogPrivate
{
GtkWidget *image;
GtkWidget *label;
GTK_TYPE_WIDGET,
GTK_PARAM_READABLE));
- g_type_class_add_private (gobject_class, sizeof (GtkMessageDialogPriv));
+ g_type_class_add_private (gobject_class, sizeof (GtkMessageDialogPrivate));
}
static void
GtkWidget *hbox;
GtkDialog *message_dialog = GTK_DIALOG (dialog);
GtkWidget *action_area, *content_area;
- GtkMessageDialogPriv *priv;
+ GtkMessageDialogPrivate *priv;
dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog,
GTK_TYPE_MESSAGE_DIALOG,
- GtkMessageDialogPriv);
+ GtkMessageDialogPrivate);
priv = dialog->priv;
content_area = gtk_dialog_get_content_area (message_dialog);
static void
setup_primary_label_font (GtkMessageDialog *dialog)
{
- GtkMessageDialogPriv *priv = dialog->priv;
+ GtkMessageDialogPrivate *priv = dialog->priv;
gint size;
PangoFontDescription *font_desc;
setup_type (GtkMessageDialog *dialog,
GtkMessageType type)
{
- GtkMessageDialogPriv *priv = dialog->priv;
+ GtkMessageDialogPrivate *priv = dialog->priv;
const gchar *stock_id = NULL;
AtkObject *atk_obj;
GParamSpec *pspec)
{
GtkMessageDialog *dialog = GTK_MESSAGE_DIALOG (object);
- GtkMessageDialogPriv *priv = dialog->priv;
+ GtkMessageDialogPrivate *priv = dialog->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkMessageDialog *dialog = GTK_MESSAGE_DIALOG (object);
- GtkMessageDialogPriv *priv = dialog->priv;
+ GtkMessageDialogPrivate *priv = dialog->priv;
switch (prop_id)
{
gtk_message_dialog_set_image (GtkMessageDialog *dialog,
GtkWidget *image)
{
- GtkMessageDialogPriv *priv;
+ GtkMessageDialogPrivate *priv;
GtkWidget *parent;
g_return_if_fail (GTK_IS_MESSAGE_DIALOG (dialog));
gtk_message_dialog_set_markup (GtkMessageDialog *message_dialog,
const gchar *str)
{
- GtkMessageDialogPriv *priv;
+ GtkMessageDialogPrivate *priv;
g_return_if_fail (GTK_IS_MESSAGE_DIALOG (message_dialog));
{
va_list args;
gchar *msg = NULL;
- GtkMessageDialogPriv *priv;
+ GtkMessageDialogPrivate *priv;
g_return_if_fail (GTK_IS_MESSAGE_DIALOG (message_dialog));
{
va_list args;
gchar *msg = NULL;
- GtkMessageDialogPriv *priv;
+ GtkMessageDialogPrivate *priv;
g_return_if_fail (GTK_IS_MESSAGE_DIALOG (message_dialog));
#define GTK_IS_MESSAGE_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MESSAGE_DIALOG))
#define GTK_MESSAGE_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass))
-typedef struct _GtkMessageDialog GtkMessageDialog;
-typedef struct _GtkMessageDialogPriv GtkMessageDialogPriv;
-typedef struct _GtkMessageDialogClass GtkMessageDialogClass;
+typedef struct _GtkMessageDialog GtkMessageDialog;
+typedef struct _GtkMessageDialogPrivate GtkMessageDialogPrivate;
+typedef struct _GtkMessageDialogClass GtkMessageDialogClass;
struct _GtkMessageDialog
{
GtkDialog parent_instance;
/*< private >*/
- GtkMessageDialogPriv *priv;
+ GtkMessageDialogPrivate *priv;
};
struct _GtkMessageDialogClass
#include "gtkprivate.h"
-struct _GtkMiscPriv
+struct _GtkMiscPrivate
{
gfloat xalign;
gfloat yalign;
0,
GTK_PARAM_READWRITE));
- g_type_class_add_private (class, sizeof (GtkMiscPriv));
+ g_type_class_add_private (class, sizeof (GtkMiscPrivate));
}
static void
gtk_misc_init (GtkMisc *misc)
{
- GtkMiscPriv *priv;
+ GtkMiscPrivate *priv;
misc->priv = G_TYPE_INSTANCE_GET_PRIVATE (misc,
GTK_TYPE_MISC,
- GtkMiscPriv);
+ GtkMiscPrivate);
priv = misc->priv;
priv->xalign = 0.5;
GParamSpec *pspec)
{
GtkMisc *misc = GTK_MISC (object);
- GtkMiscPriv *priv = misc->priv;
+ GtkMiscPrivate *priv = misc->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkMisc *misc = GTK_MISC (object);
- GtkMiscPriv *priv = misc->priv;
+ GtkMiscPrivate *priv = misc->priv;
switch (prop_id)
{
gfloat xalign,
gfloat yalign)
{
- GtkMiscPriv *priv;
+ GtkMiscPrivate *priv;
GtkWidget *widget;
g_return_if_fail (GTK_IS_MISC (misc));
gfloat *xalign,
gfloat *yalign)
{
- GtkMiscPriv *priv;
+ GtkMiscPrivate *priv;
g_return_if_fail (GTK_IS_MISC (misc));
gint xpad,
gint ypad)
{
- GtkMiscPriv *priv;
+ GtkMiscPrivate *priv;
GtkRequisition *requisition;
g_return_if_fail (GTK_IS_MISC (misc));
gint *xpad,
gint *ypad)
{
- GtkMiscPriv *priv;
+ GtkMiscPrivate *priv;
g_return_if_fail (GTK_IS_MISC (misc));
#define GTK_MISC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MISC, GtkMiscClass))
-typedef struct _GtkMisc GtkMisc;
-typedef struct _GtkMiscPriv GtkMiscPriv;
-typedef struct _GtkMiscClass GtkMiscClass;
+typedef struct _GtkMisc GtkMisc;
+typedef struct _GtkMiscPrivate GtkMiscPrivate;
+typedef struct _GtkMiscClass GtkMiscClass;
struct _GtkMisc
{
GtkWidget widget;
/* <private> */
- GtkMiscPriv *priv;
+ GtkMiscPrivate *priv;
};
struct _GtkMiscClass
N_ACTION_WIDGETS
};
-struct _GtkNotebookPriv
+struct _GtkNotebookPrivate
{
GtkNotebookDragOperation operation;
GtkNotebookPage *cur_page;
add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
- g_type_class_add_private (class, sizeof (GtkNotebookPriv));
+ g_type_class_add_private (class, sizeof (GtkNotebookPrivate));
}
static void
gtk_notebook_init (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
gtk_widget_set_can_focus (GTK_WIDGET (notebook), TRUE);
gtk_widget_set_has_window (GTK_WIDGET (notebook), FALSE);
notebook->priv = G_TYPE_INSTANCE_GET_PRIVATE (notebook,
GTK_TYPE_NOTEBOOK,
- GtkNotebookPriv);
+ GtkNotebookPrivate);
priv = notebook->priv;
priv->cur_page = NULL;
gtk_notebook_select_page (GtkNotebook *notebook,
gboolean move_focus)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (gtk_widget_is_focus (GTK_WIDGET (notebook)) && priv->show_tabs)
{
gtk_notebook_focus_tab (GtkNotebook *notebook,
GtkNotebookTab type)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list;
if (gtk_widget_is_focus (GTK_WIDGET (notebook)) && priv->show_tabs)
gtk_notebook_change_current_page (GtkNotebook *notebook,
gint offset)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *current = NULL;
if (!priv->show_tabs)
get_effective_direction (GtkNotebook *notebook,
GtkDirectionType direction)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
/* Remap the directions into the effective direction it would be for a
* GTK_POS_TOP notebook
static gint
get_effective_tab_pos (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (gtk_widget_get_direction (GTK_WIDGET (notebook)) == GTK_TEXT_DIR_RTL)
{
gtk_notebook_move_focus_out (GtkNotebook *notebook,
GtkDirectionType direction_type)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkDirectionType effective_direction = get_effective_direction (notebook, direction_type);
GtkWidget *toplevel;
static gint
reorder_tab (GtkNotebook *notebook, GList *position, GList *tab)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *elem;
if (position == tab)
GtkDirectionType direction_type,
gboolean move_to_last)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkDirectionType effective_direction = get_effective_direction (notebook, direction_type);
GtkNotebookPage *page;
GList *last, *child;
gtk_notebook_destroy (GtkObject *object)
{
GtkNotebook *notebook = GTK_NOTEBOOK (object);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->menu)
gtk_notebook_popup_disable (notebook);
GParamSpec *pspec)
{
GtkNotebook *notebook = GTK_NOTEBOOK (object);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
switch (prop_id)
{
gtk_notebook_get_event_window_position (GtkNotebook *notebook,
GdkRectangle *rectangle)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget = GTK_WIDGET (notebook);
guint border_width = gtk_container_get_border_width (GTK_CONTAINER (notebook));
GtkNotebookPage *visible_page = NULL;
gtk_notebook_map (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *children;
gint i;
gtk_notebook_unmap (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
stop_scrolling (notebook);
gtk_notebook_realize (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GdkWindowAttr attributes;
gint attributes_mask;
GdkRectangle event_window_pos;
gtk_notebook_unrealize (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gdk_window_set_user_data (priv->event_window, NULL);
gdk_window_destroy (priv->event_window);
GtkRequisition *requisition)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *children;
GtkRequisition child_requisition;
GtkAllocation *allocation)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gint tab_pos = get_effective_tab_pos (notebook);
gboolean is_rtl;
gint focus_width;
GdkEventExpose *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gint i;
if (event->window == priv->drag_window)
static gboolean
gtk_notebook_show_arrows (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gboolean show_arrow = FALSE;
GList *children;
GdkRectangle *rectangle,
GtkNotebookArrow arrow)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GdkRectangle event_window_pos;
gboolean before = ARROW_IS_BEFORE (arrow);
gboolean left = ARROW_IS_LEFT (arrow);
gint x,
gint y)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GdkRectangle arrow_rect;
GdkRectangle event_window_pos;
gint i;
gtk_notebook_do_arrow (GtkNotebook *notebook,
GtkNotebookArrow arrow)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget = GTK_WIDGET (notebook);
gboolean is_rtl, left;
GtkNotebookArrow arrow,
gint button)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget = GTK_WIDGET (notebook);
gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
gboolean left = (ARROW_IS_LEFT (arrow) && !is_rtl) ||
GdkEventScroll *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *child, *event_widget;
gint i;
static GList*
get_tab_at_pos (GtkNotebook *notebook, gint x, gint y)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *children;
GdkEventButton *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *tab;
GtkNotebookArrow arrow;
gpointer data)
{
GtkNotebook *notebook = data;
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *w;
GtkRequisition requisition;
gtk_notebook_popup_menu (GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->menu)
{
static void
stop_scrolling (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->timer)
{
get_drop_position (GtkNotebook *notebook,
guint pack)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *children, *last_child;
GtkNotebookPage *page;
gboolean is_rtl;
static void
show_drag_window (GtkNotebook *notebook,
- GtkNotebookPriv *priv,
+ GtkNotebookPrivate *priv,
GtkNotebookPage *page,
GdkDevice *device)
{
*/
static void
hide_drag_window (GtkNotebook *notebook,
- GtkNotebookPriv *priv,
+ GtkNotebookPrivate *priv,
GtkNotebookPage *page)
{
GtkWidget *widget = GTK_WIDGET (notebook);
static void
gtk_notebook_stop_reorder (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
if (priv->operation == DRAG_OPERATION_DETACH)
GdkEventButton *event)
{
GtkNotebook *notebook;
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
if (event->type != GDK_BUTTON_RELEASE)
GdkEventCrossing *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gint x, y;
if (!get_widget_coordinates (widget, (GdkEvent *)event, &x, &y))
static GtkNotebookPointerPosition
get_pointer_position (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget = GTK_WIDGET (notebook);
gint wx, wy, width, height;
gboolean is_rtl;
scroll_notebook_timer (gpointer data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (data);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPointerPosition pointer_position;
GList *element, *first_tab;
gint current_x,
gint current_y)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget;
gint dnd_threshold;
GdkRectangle rectangle = { 0, }; /* shut up gcc */
GdkEventMotion *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GtkNotebookArrow arrow;
GtkNotebookPointerPosition pointer_position;
GdkEventExpose *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (gtk_widget_has_focus (widget) && gtk_widget_is_drawable (widget) &&
priv->show_tabs && priv->cur_page &&
GtkStyle *previous)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gboolean has_before_previous;
gboolean has_before_next;
GdkDragContext *context)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *tab_label;
if (priv->dnd_timer)
GdkDragContext *context)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gtk_notebook_stop_reorder (notebook);
if (result == GTK_DRAG_RESULT_NO_TARGET)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebook *dest_notebook = NULL;
GdkDisplay *display;
gint x, y;
gtk_notebook_switch_tab_timeout (gpointer data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (data);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *tab;
gint x, y;
guint time)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GdkRectangle position;
GtkSettings *settings;
GtkNotebookArrow arrow;
guint time)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->switch_tab_timer)
{
gint x,
gint y)
{
- GtkNotebookPriv *to_priv = to->priv;
+ GtkNotebookPrivate *to_priv = to->priv;
GtkWidget *tab_label, *menu_label;
gboolean tab_expand, tab_fill, reorderable, detachable;
GList *element;
if (data->target == gdk_atom_intern_static_string ("GTK_NOTEBOOK_TAB"))
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gtk_selection_data_set (data,
data->target,
GParamSpec *pspec)
{
GtkNotebook *notebook = GTK_NOTEBOOK (container);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list;
GtkWidget *label;
gboolean expand;
GtkWidget *widget)
{
GtkNotebook *notebook = GTK_NOTEBOOK (container);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *children;
gint page_num = 0;
static gboolean
focus_tabs_in (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->show_tabs && priv->cur_page)
{
GtkDirectionType direction,
gint search_direction)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *new_page;
new_page = gtk_notebook_search_page (notebook, priv->focus_tab,
focus_child_in (GtkNotebook *notebook,
GtkDirectionType direction)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->cur_page)
return gtk_widget_child_focus (priv->cur_page->child, direction);
gint action,
GtkDirectionType direction)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->action_widget[action] &&
gtk_widget_get_visible (priv->action_widget[action]))
GtkDirectionType direction)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *old_focus_child;
GtkDirectionType effective_direction;
gint first_action;
GtkWidget *child)
{
GtkNotebook *notebook = GTK_NOTEBOOK (container);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *page_child;
GtkWidget *toplevel;
gpointer callback_data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (container);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *children;
gint i;
gpointer data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (data);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list;
GList *next = NULL;
GtkWidget *menu_label,
gint position)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
gint nchildren;
static void
gtk_notebook_redraw_tabs (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget;
GtkNotebookPage *page;
GdkRectangle redraw_rect;
static void
gtk_notebook_redraw_arrows (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (gtk_widget_get_mapped (GTK_WIDGET (notebook)) &&
gtk_notebook_show_arrows (notebook))
static gboolean
gtk_notebook_timer (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
gboolean retval = FALSE;
if (priv->timer)
static void
gtk_notebook_set_scroll_timer (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget = GTK_WIDGET (notebook);
if (!priv->timer)
GtkWidget *child,
const gchar *function)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list = g_list_find_custom (priv->children, child,
gtk_notebook_page_compare);
gtk_notebook_real_remove (GtkNotebook *notebook,
GList *list)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList * next_list;
gint need_resize = FALSE;
static void
gtk_notebook_update_labels (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GList *list;
gchar string[32];
gtk_notebook_real_page_position (GtkNotebook *notebook,
GList *list)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *work;
gint count_start;
gint direction,
gboolean find_visible)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page = NULL;
GList *old_list = NULL;
gint flag = 0;
GdkRectangle *area)
{
GtkNotebook *notebook;
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *children;
gboolean showarrow;
GtkNotebookPage *page,
GdkRectangle *area)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GdkRectangle child_area;
GdkRectangle page_area;
GtkStateType state_type;
gtk_notebook_draw_arrow (GtkNotebook *notebook,
GtkNotebookArrow nbarrow)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkStateType state_type;
GtkShadowType shadow_type;
GtkWidget *widget;
gint *max,
gint *tab_space)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget;
GList *children;
gint tab_pos = get_effective_tab_pos (notebook);
gint *n,
gint *remaining_space)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget;
GtkContainer *container;
GList *children;
gint min,
gint max)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkWidget *widget;
GtkContainer *container;
GtkNotebookPage *page;
static void
gtk_notebook_pages_allocate (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *children = NULL;
GList *last_child = NULL;
gboolean showarrow = FALSE;
GtkNotebookPage *page)
{
GtkWidget *widget = GTK_WIDGET (notebook);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkAllocation child_allocation;
GtkRequisition tab_requisition;
gint xthickness;
static void
gtk_notebook_update_tab_states (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list;
for (list = priv->children; list != NULL; list = list->next)
GtkWidget* child,
guint page_num)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list = gtk_notebook_find_child (notebook, GTK_WIDGET (child), NULL);
GtkNotebookPage *page = GTK_NOTEBOOK_PAGE (list);
gboolean child_has_focus;
gtk_notebook_switch_page (GtkNotebook *notebook,
GtkNotebookPage *page)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
guint page_num;
if (priv->cur_page == page)
gtk_notebook_page_select (GtkNotebook *notebook,
gboolean move_focus)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GtkDirectionType dir = GTK_DIR_DOWN; /* Quiet GCC */
gint tab_pos = get_effective_tab_pos (notebook);
gtk_notebook_switch_focus_tab (GtkNotebook *notebook,
GList *new_child)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *old_child;
GtkNotebookPage *page;
gtk_notebook_menu_switch_page (GtkWidget *widget,
GtkNotebookPage *page)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebook *notebook;
GList *children;
guint page_num;
gtk_notebook_menu_item_create (GtkNotebook *notebook,
GList *list)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
GtkWidget *menu_item;
GtkMenu *menu)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
g_return_if_fail (priv->menu == (GtkWidget*) menu);
gpointer data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (data);
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
GList *list;
list = g_list_find_custom (priv->children, child,
gtk_notebook_remove_page (GtkNotebook *notebook,
gint page_num)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list = NULL;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
gint
gtk_notebook_get_current_page (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
gtk_notebook_get_nth_page (GtkNotebook *notebook,
gint page_num)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *list;
gint
gtk_notebook_get_n_pages (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), 0);
gtk_notebook_page_num (GtkNotebook *notebook,
GtkWidget *child)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *children;
gint num;
gtk_notebook_set_current_page (GtkNotebook *notebook,
gint page_num)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
void
gtk_notebook_next_page (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
void
gtk_notebook_prev_page (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
gtk_notebook_set_show_border (GtkNotebook *notebook,
gboolean show_border)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
gtk_notebook_set_show_tabs (GtkNotebook *notebook,
gboolean show_tabs)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *children;
gint i;
gtk_notebook_set_tab_pos (GtkNotebook *notebook,
GtkPositionType pos)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
gtk_notebook_set_scrollable (GtkNotebook *notebook,
gboolean scrollable)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
void
gtk_notebook_popup_enable (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
void
gtk_notebook_popup_disable (GtkNotebook *notebook)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
GtkWidget *child,
GtkWidget *tab_label)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *list;
GtkWidget *child,
GtkWidget *menu_label)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *list;
gtk_notebook_child_reordered (GtkNotebook *notebook,
GtkNotebookPage *page)
{
- GtkNotebookPriv *priv = notebook->priv;
+ GtkNotebookPrivate *priv = notebook->priv;
if (priv->menu)
{
gboolean fill,
GtkPackType pack_type)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GtkNotebookPage *page;
GList *list;
GtkWidget *child,
gint position)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
GList *list, *new_list;
GtkNotebookPage *page;
gint old_pos;
gtk_notebook_set_group (GtkNotebook *notebook,
gpointer group)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
GtkWidget *widget,
GtkPackType pack_type)
{
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
g_return_if_fail (!widget || GTK_IS_WIDGET (widget));
GTK_NOTEBOOK_TAB_LAST
} GtkNotebookTab;
-typedef struct _GtkNotebook GtkNotebook;
-typedef struct _GtkNotebookPriv GtkNotebookPriv;
-typedef struct _GtkNotebookClass GtkNotebookClass;
+typedef struct _GtkNotebook GtkNotebook;
+typedef struct _GtkNotebookPrivate GtkNotebookPrivate;
+typedef struct _GtkNotebookClass GtkNotebookClass;
struct _GtkNotebook
{
GtkContainer container;
/* <private> */
- GtkNotebookPriv *priv;
+ GtkNotebookPrivate *priv;
};
struct _GtkNotebookClass
#define MIN_VERTICAL_BAR_HEIGHT 80
-struct _GtkProgressBarPriv
+struct _GtkProgressBarPrivate
{
GtkProgressBarOrientation orientation;
1, G_MAXINT, MIN_VERTICAL_BAR_HEIGHT,
G_PARAM_READWRITE));
- g_type_class_add_private (class, sizeof (GtkProgressBarPriv));
+ g_type_class_add_private (class, sizeof (GtkProgressBarPrivate));
}
static void
gtk_progress_bar_init (GtkProgressBar *pbar)
{
- GtkProgressBarPriv *priv;
+ GtkProgressBarPrivate *priv;
pbar->priv = G_TYPE_INSTANCE_GET_PRIVATE (pbar,
GTK_TYPE_PROGRESS_BAR,
- GtkProgressBarPriv);
+ GtkProgressBarPrivate);
priv = pbar->priv;
priv->blocks = 10;
GParamSpec *pspec)
{
GtkProgressBar *pbar = GTK_PROGRESS_BAR (object);
- GtkProgressBarPriv* priv = pbar->priv;
+ GtkProgressBarPrivate* priv = pbar->priv;
switch (prop_id)
{
static void
gtk_progress_bar_real_update (GtkProgressBar *pbar)
{
- GtkProgressBarPriv *priv;
+ GtkProgressBarPrivate *priv;
GtkWidget *widget;
g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
gtk_progress_bar_finalize (GObject *object)
{
GtkProgressBar *pbar = GTK_PROGRESS_BAR (object);
- GtkProgressBarPriv *priv = pbar->priv;
+ GtkProgressBarPrivate *priv = pbar->priv;
g_free (priv->text);
static gchar *
get_current_text (GtkProgressBar *pbar)
{
- GtkProgressBarPriv *priv = pbar->priv;
+ GtkProgressBarPrivate *priv = pbar->priv;
if (priv->text)
return g_strdup (priv->text);
GtkRequisition *requisition)
{
GtkProgressBar *pbar;
- GtkProgressBarPriv *priv;
+ GtkProgressBarPrivate *priv;
GtkStyle *style;
gchar *buf;
PangoRectangle logical_rect;
static void
gtk_progress_bar_act_mode_enter (GtkProgressBar *pbar)
{
- GtkProgressBarPriv *priv = pbar->priv;
+ GtkProgressBarPrivate *priv = pbar->priv;
GtkAllocation allocation;
GtkStyle *style;
GtkWidget *widget = GTK_WIDGET (pbar);
gint *offset,
gint *amount)
{
- GtkProgressBarPriv *priv = pbar->priv;
+ GtkProgressBarPrivate *priv = pbar->priv;
GtkAllocation allocation;
GtkWidget *widget = GTK_WIDGET (pbar);
gint amount,
GtkProgressBarOrientation orientation)
{
- GtkProgressBarPriv *priv = pbar->priv;
+ GtkProgressBarPrivate *priv = pbar->priv;
GtkAllocation allocation;
GtkStyle *style;
GtkWidget *widget = GTK_WIDGET (pbar);
static void
gtk_progress_bar_paint (GtkProgressBar *pbar)
{
- GtkProgressBarPriv *priv = pbar->priv;
+ GtkProgressBarPrivate *priv = pbar->priv;
GtkAllocation allocation;
GtkWidget *widget = GTK_WIDGET (pbar);
GtkProgressBarOrientation orientation;
gtk_progress_bar_set_activity_mode (GtkProgressBar *pbar,
gboolean activity_mode)
{
- GtkProgressBarPriv *priv = pbar->priv;
+ GtkProgressBarPrivate *priv = pbar->priv;
activity_mode = !!activity_mode;
gtk_progress_bar_set_fraction (GtkProgressBar *pbar,
gdouble fraction)
{
- GtkProgressBarPriv* priv;
+ GtkProgressBarPrivate* priv;
g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
gtk_progress_bar_set_text (GtkProgressBar *pbar,
const gchar *text)
{
- GtkProgressBarPriv *priv;
+ GtkProgressBarPrivate *priv;
g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
gtk_progress_bar_set_show_text (GtkProgressBar *pbar,
gboolean show_text)
{
- GtkProgressBarPriv *priv;
+ GtkProgressBarPrivate *priv;
g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
gtk_progress_bar_set_pulse_step (GtkProgressBar *pbar,
gdouble fraction)
{
- GtkProgressBarPriv *priv;
+ GtkProgressBarPrivate *priv;
g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
gtk_progress_bar_set_orientation (GtkProgressBar *pbar,
GtkProgressBarOrientation orientation)
{
- GtkProgressBarPriv *priv;
+ GtkProgressBarPrivate *priv;
g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
gtk_progress_bar_set_ellipsize (GtkProgressBar *pbar,
PangoEllipsizeMode mode)
{
- GtkProgressBarPriv *priv;
+ GtkProgressBarPrivate *priv;
g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
g_return_if_fail (mode >= PANGO_ELLIPSIZE_NONE &&
#define GTK_PROGRESS_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PROGRESS_BAR, GtkProgressBarClass))
-typedef struct _GtkProgressBar GtkProgressBar;
-typedef struct _GtkProgressBarPriv GtkProgressBarPriv;
-typedef struct _GtkProgressBarClass GtkProgressBarClass;
+typedef struct _GtkProgressBar GtkProgressBar;
+typedef struct _GtkProgressBarPrivate GtkProgressBarPrivate;
+typedef struct _GtkProgressBarClass GtkProgressBarClass;
typedef enum
{
GtkWidget parent;
/* <private> */
- GtkProgressBarPriv *priv;
+ GtkProgressBarPrivate *priv;
};
struct _GtkProgressBarClass
*/
-struct _GtkRadioButtonPriv
+struct _GtkRadioButtonPrivate
{
GSList *group;
};
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- g_type_class_add_private (class, sizeof (GtkRadioButtonPriv));
+ g_type_class_add_private (class, sizeof (GtkRadioButtonPrivate));
}
static void
gtk_radio_button_init (GtkRadioButton *radio_button)
{
- GtkRadioButtonPriv *priv;
+ GtkRadioButtonPrivate *priv;
radio_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (radio_button,
GTK_TYPE_RADIO_BUTTON,
- GtkRadioButtonPriv);
+ GtkRadioButtonPrivate);
priv = radio_button->priv;
gtk_widget_set_has_window (GTK_WIDGET (radio_button), FALSE);
gtk_radio_button_set_group (GtkRadioButton *radio_button,
GSList *group)
{
- GtkRadioButtonPriv *priv;
+ GtkRadioButtonPrivate *priv;
GtkWidget *old_group_singleton = NULL;
GtkWidget *new_group_singleton = NULL;
{
GtkWidget *old_group_singleton = NULL;
GtkRadioButton *radio_button = GTK_RADIO_BUTTON (object);
- GtkRadioButtonPriv *priv = radio_button->priv;
+ GtkRadioButtonPrivate *priv = radio_button->priv;
GtkRadioButton *tmp_button;
GSList *tmp_list;
gboolean was_in_group;
GtkDirectionType direction)
{
GtkRadioButton *radio_button = GTK_RADIO_BUTTON (widget);
- GtkRadioButtonPriv *priv = radio_button->priv;
+ GtkRadioButtonPrivate *priv = radio_button->priv;
GSList *tmp_slist;
/* Radio buttons with draw_indicator unset focus "normally", since
gtk_radio_button_clicked (GtkButton *button)
{
GtkRadioButton *radio_button = GTK_RADIO_BUTTON (button);
- GtkRadioButtonPriv *priv = radio_button->priv;
+ GtkRadioButtonPrivate *priv = radio_button->priv;
GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (button);
GtkToggleButton *tmp_button;
GtkStateType new_state;
#define GTK_RADIO_BUTTON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RADIO_BUTTON, GtkRadioButtonClass))
-typedef struct _GtkRadioButton GtkRadioButton;
-typedef struct _GtkRadioButtonPriv GtkRadioButtonPriv;
-typedef struct _GtkRadioButtonClass GtkRadioButtonClass;
+typedef struct _GtkRadioButton GtkRadioButton;
+typedef struct _GtkRadioButtonPrivate GtkRadioButtonPrivate;
+typedef struct _GtkRadioButtonClass GtkRadioButtonClass;
struct _GtkRadioButton
{
GtkCheckButton check_button;
/* <private> */
- GtkRadioButtonPriv *priv;
+ GtkRadioButtonPrivate *priv;
};
struct _GtkRadioButtonClass
#include "gtkintl.h"
-struct _GtkRadioMenuItemPriv
+struct _GtkRadioMenuItemPrivate
{
GSList *group;
};
gtk_radio_menu_item_set_group (GtkRadioMenuItem *radio_menu_item,
GSList *group)
{
- GtkRadioMenuItemPriv *priv;
+ GtkRadioMenuItemPrivate *priv;
GtkWidget *old_group_singleton = NULL;
GtkWidget *new_group_singleton = NULL;
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- g_type_class_add_private (klass, sizeof (GtkRadioMenuItemPriv));
+ g_type_class_add_private (klass, sizeof (GtkRadioMenuItemPrivate));
}
static void
gtk_radio_menu_item_init (GtkRadioMenuItem *radio_menu_item)
{
- GtkRadioMenuItemPriv *priv;
+ GtkRadioMenuItemPrivate *priv;
radio_menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (radio_menu_item,
GTK_TYPE_RADIO_MENU_ITEM,
- GtkRadioMenuItemPriv);
+ GtkRadioMenuItemPrivate);
priv = radio_menu_item->priv;
priv->group = g_slist_prepend (NULL, radio_menu_item);
gtk_radio_menu_item_destroy (GtkObject *object)
{
GtkRadioMenuItem *radio_menu_item = GTK_RADIO_MENU_ITEM (object);
- GtkRadioMenuItemPriv *priv = radio_menu_item->priv;
+ GtkRadioMenuItemPrivate *priv = radio_menu_item->priv;
GtkWidget *old_group_singleton = NULL;
GtkRadioMenuItem *tmp_menu_item;
GSList *tmp_list;
gtk_radio_menu_item_activate (GtkMenuItem *menu_item)
{
GtkRadioMenuItem *radio_menu_item = GTK_RADIO_MENU_ITEM (menu_item);
- GtkRadioMenuItemPriv *priv = radio_menu_item->priv;
+ GtkRadioMenuItemPrivate *priv = radio_menu_item->priv;
GtkCheckMenuItem *check_menu_item = GTK_CHECK_MENU_ITEM (menu_item);
GtkCheckMenuItem *tmp_menu_item;
GtkAction *action;
#define GTK_RADIO_MENU_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RADIO_MENU_ITEM, GtkRadioMenuItemClass))
-typedef struct _GtkRadioMenuItem GtkRadioMenuItem;
-typedef struct _GtkRadioMenuItemPriv GtkRadioMenuItemPriv;
-typedef struct _GtkRadioMenuItemClass GtkRadioMenuItemClass;
+typedef struct _GtkRadioMenuItem GtkRadioMenuItem;
+typedef struct _GtkRadioMenuItemPrivate GtkRadioMenuItemPrivate;
+typedef struct _GtkRadioMenuItemClass GtkRadioMenuItemClass;
struct _GtkRadioMenuItem
{
GtkCheckMenuItem check_menu_item;
/* <private> */
- GtkRadioMenuItemPriv *priv;
+ GtkRadioMenuItemPrivate *priv;
};
struct _GtkRadioMenuItemClass
MOUSE_WIDGET /* inside widget but not in any of the above GUI elements */
} MouseLocation;
-struct _GtkRangePriv
+struct _GtkRangePrivate
{
MouseLocation mouse_location;
/* last mouse coords we got, or -1 if mouse is outside the range */
FALSE,
GTK_PARAM_READABLE));
- g_type_class_add_private (class, sizeof (GtkRangePriv));
+ g_type_class_add_private (class, sizeof (GtkRangePrivate));
}
static void
GParamSpec *pspec)
{
GtkRange *range = GTK_RANGE (object);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkRange *range = GTK_RANGE (object);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
switch (prop_id)
{
static void
gtk_range_init (GtkRange *range)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
range->priv = G_TYPE_INSTANCE_GET_PRIVATE (range,
GTK_TYPE_RANGE,
- GtkRangePriv);
+ GtkRangePrivate);
priv = range->priv;
gtk_widget_set_has_window (GTK_WIDGET (range), FALSE);
GtkAdjustment*
gtk_range_get_adjustment (GtkRange *range)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_val_if_fail (GTK_IS_RANGE (range), NULL);
gtk_range_set_update_policy (GtkRange *range,
GtkUpdateType policy)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_adjustment (GtkRange *range,
GtkAdjustment *adjustment)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_inverted (GtkRange *range,
gboolean setting)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_flippable (GtkRange *range,
gboolean flippable)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_slider_size_fixed (GtkRange *range,
gboolean size_fixed)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_min_slider_size (GtkRange *range,
gint min_size)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
g_return_if_fail (min_size > 0);
gtk_range_get_range_rect (GtkRange *range,
GdkRectangle *range_rect)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
g_return_if_fail (range_rect != NULL);
gint *slider_start,
gint *slider_end)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_lower_stepper_sensitivity (GtkRange *range,
GtkSensitivityType sensitivity)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_upper_stepper_sensitivity (GtkRange *range,
GtkSensitivityType sensitivity)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gdouble step,
gdouble page)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gdouble min,
gdouble max)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
gdouble value;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_value (GtkRange *range,
gdouble value)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_show_fill_level (GtkRange *range,
gboolean show_fill_level)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_restrict_to_fill_level (GtkRange *range,
gboolean restrict_to_fill_level)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
gtk_range_set_fill_level (GtkRange *range,
gdouble fill_level)
{
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
g_return_if_fail (GTK_IS_RANGE (range));
static gboolean
should_invert (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
return
gtk_range_destroy (GtkObject *object)
{
GtkRange *range = GTK_RANGE (object);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gtk_range_remove_step_timer (range);
gtk_range_remove_update_timer (range);
GtkAllocation *allocation)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gtk_widget_set_allocation (widget, allocation);
{
GtkAllocation allocation;
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
GdkWindow *window;
GdkWindowAttr attributes;
gint attributes_mask;
gtk_range_unrealize (GtkWidget *widget)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gtk_range_remove_step_timer (range);
gtk_range_remove_update_timer (range);
gtk_range_map (GtkWidget *widget)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gdk_window_show (priv->event_window);
gtk_range_unmap (GtkWidget *widget)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
stop_scrolling (range);
static const gchar *
gtk_range_get_slider_detail (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
const gchar *slider_detail;
if (priv->slider_detail_quark)
gtk_range_get_stepper_detail (GtkRange *range,
Stepper stepper)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
const gchar *stepper_detail;
gboolean need_orientation;
gboolean need_position;
gboolean prelighted,
GdkRectangle *area)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
GtkAllocation allocation;
GtkStateType state_type;
GtkShadowType shadow_type;
{
GtkAllocation allocation;
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gboolean sensitive;
GtkStateType state;
GtkShadowType shadow_type;
MouseLocation location,
gint button)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
if (device == priv->grab_device)
return;
static void
range_grab_remove (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
MouseLocation location;
if (priv->grab_device)
static GtkScrollType
range_get_scroll_for_grab (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gboolean invert;
invert = should_invert (range);
coord_to_value (GtkRange *range,
gint coord)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gdouble frac;
gdouble value;
gint trough_length;
{
GdkDevice *device;
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
device = gdk_event_get_device ((GdkEvent *) event);
device = gdk_device_get_associated_device (device);
GdkEventButton *event)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
GdkDevice *device;
if (!gtk_widget_has_focus (widget))
gint mouse_x,
gint mouse_y)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gint delta;
gint c;
gdouble new_value;
GdkEventGrabBroken *event)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
GdkDevice *device;
device = gdk_event_get_device ((GdkEvent *) event);
GdkEventButton *event)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
GdkDevice *device;
if (event->window == priv->event_window)
_gtk_range_get_wheel_delta (GtkRange *range,
GdkScrollDirection direction)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
GtkAdjustment *adj = priv->adjustment;
gdouble delta;
GdkEventScroll *event)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
if (gtk_widget_get_realized (widget))
{
GdkEventMotion *event)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gdk_event_request_motions (event);
GdkEventCrossing *event)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
priv->mouse_x = event->x;
priv->mouse_y = event->y;
GdkEventCrossing *event)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
priv->mouse_x = -1;
priv->mouse_y = -1;
gtk_range_grab_notify (GtkWidget *widget,
gboolean was_grabbed)
{
- GtkRangePriv *priv = GTK_RANGE (widget)->priv;
+ GtkRangePrivate *priv = GTK_RANGE (widget)->priv;
if (priv->grab_device &&
gtk_widget_device_is_shadowed (widget, priv->grab_device))
}
static gboolean
-layout_changed (GtkRangePriv *priv1,
- GtkRangePriv *priv2)
+layout_changed (GtkRangePrivate *priv1,
+ GtkRangePrivate *priv2)
{
check_rectangle (priv1->slider, priv2->slider);
check_rectangle (priv1->trough, priv2->trough);
gpointer data)
{
GtkRange *range = GTK_RANGE (data);
- GtkRangePriv *priv = range->priv;
- GtkRangePriv priv_aux = *priv;
+ GtkRangePrivate *priv = range->priv;
+ GtkRangePrivate priv_aux = *priv;
priv->recalc_marks = TRUE;
priv->need_recalc = TRUE;
force_repaint (gpointer data)
{
GtkRange *range = GTK_RANGE (data);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
GtkWidget *widget = GTK_WIDGET (range);
priv->repaint_id = 0;
gpointer data)
{
GtkRange *range = GTK_RANGE (data);
- GtkRangePriv *priv = range->priv;
- GtkRangePriv priv_aux = *priv;
+ GtkRangePrivate *priv = range->priv;
+ GtkRangePrivate priv_aux = *priv;
priv->need_recalc = TRUE;
gtk_range_calc_layout (range, priv->adjustment->value);
GtkStyle *previous_style)
{
GtkRange *range = GTK_RANGE (widget);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
priv->need_recalc = TRUE;
gdouble oldval,
gdouble *newval)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gint i;
gdouble mark;
static void
step_back (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gdouble newval;
gboolean handled;
static void
step_forward (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gdouble newval;
gboolean handled;
static void
page_back (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gdouble newval;
gboolean handled;
static void
page_forward (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gdouble newval;
gboolean handled;
static void
scroll_begin (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gboolean handled;
g_signal_emit (range, signals[CHANGE_VALUE], 0,
static void
scroll_end (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gdouble newval;
gboolean handled;
gtk_range_scroll (GtkRange *range,
GtkScrollType scroll)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gdouble old_value = priv->adjustment->value;
switch (scroll)
gtk_range_move_slider (GtkRange *range,
GtkScrollType scroll)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gboolean cursor_only;
g_object_get (gtk_widget_get_settings (GTK_WIDGET (range)),
static gboolean
gtk_range_update_mouse_location (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
GtkAllocation allocation;
gint x, y;
MouseLocation old;
gboolean *has_steppers_cd,
gint *slider_length_p)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gint slider_length;
gint n_steppers;
gint n_steppers_ab;
gtk_range_calc_layout (GtkRange *range,
gdouble adjustment_value)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gint slider_width, stepper_size, focus_width, trough_border, stepper_spacing;
gint slider_length;
GtkBorder border;
get_area (GtkRange *range,
MouseLocation location)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
switch (location)
{
static void
gtk_range_calc_marks (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gint i;
if (!priv->recalc_marks)
GtkScrollType scroll,
gdouble value)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
/* potentially adjust the bounds _before_ we clamp */
g_signal_emit (range, signals[ADJUST_BOUNDS], 0, value);
static void
gtk_range_update_value (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gtk_range_remove_update_timer (range);
second_timeout (gpointer data)
{
GtkRange *range = GTK_RANGE (data);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gtk_range_scroll (range, priv->timer->step);
initial_timeout (gpointer data)
{
GtkRange *range = GTK_RANGE (data);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
GtkSettings *settings;
guint timeout;
gtk_range_add_step_timer (GtkRange *range,
GtkScrollType step)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
GtkSettings *settings;
guint timeout;
static void
gtk_range_remove_step_timer (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
if (priv->timer)
{
update_timeout (gpointer data)
{
GtkRange *range = GTK_RANGE (data);
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gtk_range_update_value (range);
priv->update_timeout_id = 0;
static void
gtk_range_reset_update_timer (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gtk_range_remove_update_timer (range);
static void
gtk_range_remove_update_timer (GtkRange *range)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
if (priv->update_timeout_id != 0)
{
gdouble *values,
gint n_values)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gint i;
g_free (priv->marks);
_gtk_range_get_stop_positions (GtkRange *range,
gint **values)
{
- GtkRangePriv *priv = range->priv;
+ GtkRangePrivate *priv = range->priv;
gtk_range_calc_marks (range);
#define GTK_IS_RANGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RANGE))
#define GTK_RANGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RANGE, GtkRangeClass))
-typedef struct _GtkRange GtkRange;
-typedef struct _GtkRangePriv GtkRangePriv;
-typedef struct _GtkRangeClass GtkRangeClass;
+typedef struct _GtkRange GtkRange;
+typedef struct _GtkRangePrivate GtkRangePrivate;
+typedef struct _GtkRangeClass GtkRangeClass;
struct _GtkRange
{
GtkWidget widget;
- GtkRangePriv *priv;
+ GtkRangePrivate *priv;
};
struct _GtkRangeClass
#define ROUND(x) ((int) ((x) + 0.5))
-struct _GtkRulerPriv
+struct _GtkRulerPrivate
{
GtkOrientation orientation;
GtkRulerMetric *metric;
GTK_PIXELS,
GTK_PARAM_READWRITE));
- g_type_class_add_private (gobject_class, sizeof (GtkRulerPriv));
+ g_type_class_add_private (gobject_class, sizeof (GtkRulerPrivate));
}
static void
gtk_ruler_init (GtkRuler *ruler)
{
GtkWidget *widget = GTK_WIDGET (ruler);
- GtkRulerPriv *priv;
+ GtkRulerPrivate *priv;
ruler->priv = G_TYPE_INSTANCE_GET_PRIVATE (ruler,
GTK_TYPE_RULER,
- GtkRulerPriv);
+ GtkRulerPrivate);
priv = ruler->priv;
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
GParamSpec *pspec)
{
GtkRuler *ruler = GTK_RULER (object);
- GtkRulerPriv *priv = ruler->priv;
+ GtkRulerPrivate *priv = ruler->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkRuler *ruler = GTK_RULER (object);
- GtkRulerPriv *priv = ruler->priv;
+ GtkRulerPrivate *priv = ruler->priv;
switch (prop_id)
{
gtk_ruler_set_metric (GtkRuler *ruler,
GtkMetricType metric)
{
- GtkRulerPriv *priv;
+ GtkRulerPrivate *priv;
g_return_if_fail (GTK_IS_RULER (ruler));
GtkMetricType
gtk_ruler_get_metric (GtkRuler *ruler)
{
- GtkRulerPriv *priv;
+ GtkRulerPrivate *priv;
gint i;
g_return_val_if_fail (GTK_IS_RULER (ruler), 0);
gdouble position,
gdouble max_size)
{
- GtkRulerPriv *priv;
+ GtkRulerPrivate *priv;
g_return_if_fail (GTK_IS_RULER (ruler));
gdouble *position,
gdouble *max_size)
{
- GtkRulerPriv *priv;
+ GtkRulerPrivate *priv;
g_return_if_fail (GTK_IS_RULER (ruler));
gtk_ruler_unrealize (GtkWidget *widget)
{
GtkRuler *ruler = GTK_RULER (widget);
- GtkRulerPriv *priv = ruler->priv;
+ GtkRulerPrivate *priv = ruler->priv;
if (priv->backing_store)
{
GtkRequisition *requisition)
{
GtkRuler *ruler = GTK_RULER (widget);
- GtkRulerPriv *priv = ruler->priv;
+ GtkRulerPrivate *priv = ruler->priv;
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
GdkEventMotion *event)
{
GtkRuler *ruler = GTK_RULER (widget);
- GtkRulerPriv *priv = ruler->priv;
+ GtkRulerPrivate *priv = ruler->priv;
gint x;
gint y;
if (gtk_widget_is_drawable (widget))
{
GtkRuler *ruler = GTK_RULER (widget);
- GtkRulerPriv *priv = ruler->priv;
+ GtkRulerPrivate *priv = ruler->priv;
cairo_t *cr;
gtk_ruler_draw_ticks (ruler);
static void
gtk_ruler_make_pixmap (GtkRuler *ruler)
{
- GtkRulerPriv *priv = ruler->priv;
+ GtkRulerPrivate *priv = ruler->priv;
GtkWidget *widget;
gint width;
gint height;
gtk_ruler_real_draw_ticks (GtkRuler *ruler)
{
GtkWidget *widget = GTK_WIDGET (ruler);
- GtkRulerPriv *priv = ruler->priv;
+ GtkRulerPrivate *priv = ruler->priv;
cairo_t *cr;
gint i, j;
gint width, height;
gtk_ruler_real_draw_pos (GtkRuler *ruler)
{
GtkWidget *widget = GTK_WIDGET (ruler);
- GtkRulerPriv *priv = ruler->priv;
+ GtkRulerPrivate *priv = ruler->priv;
gint x, y;
gint width, height;
gint bs_width, bs_height;
#define GTK_RULER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RULER, GtkRulerClass))
-typedef struct _GtkRuler GtkRuler;
-typedef struct _GtkRulerPriv GtkRulerPriv;
-typedef struct _GtkRulerClass GtkRulerClass;
-typedef struct _GtkRulerMetric GtkRulerMetric;
+typedef struct _GtkRuler GtkRuler;
+typedef struct _GtkRulerPrivate GtkRulerPrivate;
+typedef struct _GtkRulerClass GtkRulerClass;
+typedef struct _GtkRulerMetric GtkRulerMetric;
/* All distances below are in 1/72nd's of an inch. (According to
* Adobe that's a point, but points are really 1/72.27 in.)
GtkWidget widget;
/* <private> */
- GtkRulerPriv *priv;
+ GtkRulerPrivate *priv;
};
struct _GtkRulerClass
typedef struct _GtkScaleMark GtkScaleMark;
-struct _GtkScalePriv
+struct _GtkScalePrivate
{
PangoLayout *layout;
add_slider_binding (binding_set, GDK_KP_End, 0,
GTK_SCROLL_END);
- g_type_class_add_private (gobject_class, sizeof (GtkScalePriv));
+ g_type_class_add_private (gobject_class, sizeof (GtkScalePrivate));
}
static void
static void
gtk_scale_init (GtkScale *scale)
{
- GtkScalePriv *priv;
+ GtkScalePrivate *priv;
GtkRange *range = GTK_RANGE (scale);
scale->priv = G_TYPE_INSTANCE_GET_PRIVATE (scale,
GTK_TYPE_SCALE,
- GtkScalePriv);
+ GtkScalePrivate);
priv = scale->priv;
gtk_widget_set_can_focus (GTK_WIDGET (scale), TRUE);
GParamSpec *pspec)
{
GtkScale *scale = GTK_SCALE (object);
- GtkScalePriv *priv = scale->priv;
+ GtkScalePrivate *priv = scale->priv;
switch (prop_id)
{
gtk_scale_set_digits (GtkScale *scale,
gint digits)
{
- GtkScalePriv *priv;
+ GtkScalePrivate *priv;
GtkRange *range;
g_return_if_fail (GTK_IS_SCALE (scale));
gtk_scale_set_draw_value (GtkScale *scale,
gboolean draw_value)
{
- GtkScalePriv *priv;
+ GtkScalePrivate *priv;
g_return_if_fail (GTK_IS_SCALE (scale));
gtk_scale_set_value_pos (GtkScale *scale,
GtkPositionType pos)
{
- GtkScalePriv *priv;
+ GtkScalePrivate *priv;
GtkWidget *widget;
g_return_if_fail (GTK_IS_SCALE (scale));
gtk_scale_get_range_border (GtkRange *range,
GtkBorder *border)
{
- GtkScalePriv *priv;
+ GtkScalePrivate *priv;
GtkWidget *widget;
GtkScale *scale;
gint w, h;
gint *width,
gint *height)
{
- GtkScalePriv *priv = scale->priv;
+ GtkScalePrivate *priv = scale->priv;
GtkRange *range;
if (priv->draw_value)
gint *width2,
gint *height2)
{
- GtkScalePriv *priv = scale->priv;
+ GtkScalePrivate *priv = scale->priv;
PangoLayout *layout;
PangoRectangle logical_rect;
GSList *m;
GdkEventExpose *event)
{
GtkScale *scale = GTK_SCALE (widget);
- GtkScalePriv *priv = scale->priv;
+ GtkScalePrivate *priv = scale->priv;
GtkRange *range = GTK_RANGE (scale);
GtkStateType state_type;
GtkStyle *style;
gint *x,
gint *y)
{
- GtkScalePriv *priv = scale->priv;
+ GtkScalePrivate *priv = scale->priv;
GtkAllocation allocation;
GtkWidget *widget = GTK_WIDGET (scale);
GtkRange *range = GTK_RANGE (widget);
_gtk_scale_format_value (GtkScale *scale,
gdouble value)
{
- GtkScalePriv *priv = scale->priv;
+ GtkScalePrivate *priv = scale->priv;
gchar *fmt = NULL;
g_signal_emit (scale,
PangoLayout *
gtk_scale_get_layout (GtkScale *scale)
{
- GtkScalePriv *priv;
+ GtkScalePrivate *priv;
gchar *txt;
g_return_val_if_fail (GTK_IS_SCALE (scale), NULL);
void
_gtk_scale_clear_layout (GtkScale *scale)
{
- GtkScalePriv *priv = scale->priv;
+ GtkScalePrivate *priv = scale->priv;
g_return_if_fail (GTK_IS_SCALE (scale));
void
gtk_scale_clear_marks (GtkScale *scale)
{
- GtkScalePriv *priv;
+ GtkScalePrivate *priv;
g_return_if_fail (GTK_IS_SCALE (scale));
GtkPositionType position,
const gchar *markup)
{
- GtkScalePriv *priv;
+ GtkScalePrivate *priv;
GtkScaleMark *mark;
GSList *m;
gdouble *values;
#define GTK_SCALE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCALE, GtkScaleClass))
-typedef struct _GtkScale GtkScale;
-typedef struct _GtkScalePriv GtkScalePriv;
-typedef struct _GtkScaleClass GtkScaleClass;
+typedef struct _GtkScale GtkScale;
+typedef struct _GtkScalePrivate GtkScalePrivate;
+typedef struct _GtkScaleClass GtkScaleClass;
struct _GtkScale
{
GtkRange range;
/* <private> */
- GtkScalePriv *priv;
+ GtkScalePrivate *priv;
};
struct _GtkScaleClass
*/
-struct _GtkSeparatorPriv
+struct _GtkSeparatorPrivate
{
GtkOrientation orientation;
};
PROP_ORIENTATION,
"orientation");
- g_type_class_add_private (object_class, sizeof (GtkSeparatorPriv));
+ g_type_class_add_private (object_class, sizeof (GtkSeparatorPrivate));
}
static void
gtk_separator_init (GtkSeparator *separator)
{
GtkWidget *widget = GTK_WIDGET (separator);
- GtkSeparatorPriv *private;
+ GtkSeparatorPrivate *private;
separator->priv = G_TYPE_INSTANCE_GET_PRIVATE (separator,
GTK_TYPE_SEPARATOR,
- GtkSeparatorPriv);
+ GtkSeparatorPrivate);
private = separator->priv;
gtk_widget_set_has_window (GTK_WIDGET (separator), FALSE);
GParamSpec *pspec)
{
GtkSeparator *separator = GTK_SEPARATOR (object);
- GtkSeparatorPriv *private = separator->priv;
+ GtkSeparatorPrivate *private = separator->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkSeparator *separator = GTK_SEPARATOR (object);
- GtkSeparatorPriv *private = separator->priv;
+ GtkSeparatorPrivate *private = separator->priv;
switch (prop_id)
{
GtkRequisition *requisition)
{
GtkSeparator *separator = GTK_SEPARATOR (widget);
- GtkSeparatorPriv *private = separator->priv;
+ GtkSeparatorPrivate *private = separator->priv;
gboolean wide_separators;
gint separator_width;
gint separator_height;
GdkEventExpose *event)
{
GtkSeparator *separator = GTK_SEPARATOR (widget);
- GtkSeparatorPriv *private = separator->priv;
+ GtkSeparatorPrivate *private = separator->priv;
gboolean wide_separators;
gint separator_width;
gint separator_height;
#define GTK_SEPARATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEPARATOR, GtkSeparatorClass))
-typedef struct _GtkSeparator GtkSeparator;
-typedef struct _GtkSeparatorPriv GtkSeparatorPriv;
-typedef struct _GtkSeparatorClass GtkSeparatorClass;
+typedef struct _GtkSeparator GtkSeparator;
+typedef struct _GtkSeparatorPrivate GtkSeparatorPrivate;
+typedef struct _GtkSeparatorClass GtkSeparatorClass;
struct _GtkSeparator
{
GtkWidget widget;
- GtkSeparatorPriv *priv;
+ GtkSeparatorPrivate *priv;
};
struct _GtkSeparatorClass
-struct _GtkSizeGroupPriv
+struct _GtkSizeGroupPrivate
{
GtkRequisition requisition;
GSList **groups,
GSList **widgets)
{
- GtkSizeGroupPriv *priv = group->priv;
+ GtkSizeGroupPrivate *priv = group->priv;
GSList *tmp_widgets;
*groups = g_slist_prepend (*groups, group);
while (tmp_groups)
{
GtkSizeGroup *tmp_group = tmp_groups->data;
- GtkSizeGroupPriv *tmp_priv = tmp_group->priv;
+ GtkSizeGroupPrivate *tmp_priv = tmp_group->priv;
if ((tmp_priv->mode == GTK_SIZE_GROUP_BOTH || tmp_priv->mode == mode) &&
!is_visited (tmp_group))
while (tmp_list)
{
GtkSizeGroup *tmp_group = tmp_list->data;
- GtkSizeGroupPriv *tmp_priv = tmp_group->priv;
+ GtkSizeGroupPrivate *tmp_priv = tmp_group->priv;
tmp_priv->have_width = FALSE;
tmp_priv->have_height = FALSE;
static void
queue_resize_on_group (GtkSizeGroup *size_group)
{
- GtkSizeGroupPriv *priv = size_group->priv;
+ GtkSizeGroupPrivate *priv = size_group->priv;
if (priv->widgets)
queue_resize_on_widget (priv->widgets->data, TRUE);
FALSE,
GTK_PARAM_READWRITE));
- g_type_class_add_private (klass, sizeof (GtkSizeGroupPriv));
+ g_type_class_add_private (klass, sizeof (GtkSizeGroupPrivate));
initialize_size_group_quarks ();
}
static void
gtk_size_group_init (GtkSizeGroup *size_group)
{
- GtkSizeGroupPriv *priv;
+ GtkSizeGroupPrivate *priv;
size_group->priv = G_TYPE_INSTANCE_GET_PRIVATE (size_group,
GTK_TYPE_SIZE_GROUP,
- GtkSizeGroupPriv);
+ GtkSizeGroupPrivate);
priv = size_group->priv;
priv->widgets = NULL;
GParamSpec *pspec)
{
GtkSizeGroup *size_group = GTK_SIZE_GROUP (object);
- GtkSizeGroupPriv *priv = size_group->priv;
+ GtkSizeGroupPrivate *priv = size_group->priv;
switch (prop_id)
{
gtk_size_group_new (GtkSizeGroupMode mode)
{
GtkSizeGroup *size_group = g_object_new (GTK_TYPE_SIZE_GROUP, NULL);
- GtkSizeGroupPriv *priv = size_group->priv;
+ GtkSizeGroupPrivate *priv = size_group->priv;
priv->mode = mode;
gtk_size_group_set_mode (GtkSizeGroup *size_group,
GtkSizeGroupMode mode)
{
- GtkSizeGroupPriv *priv;
+ GtkSizeGroupPrivate *priv;
g_return_if_fail (GTK_IS_SIZE_GROUP (size_group));
gtk_size_group_set_ignore_hidden (GtkSizeGroup *size_group,
gboolean ignore_hidden)
{
- GtkSizeGroupPriv *priv;
+ GtkSizeGroupPrivate *priv;
g_return_if_fail (GTK_IS_SIZE_GROUP (size_group));
gtk_size_group_add_widget (GtkSizeGroup *size_group,
GtkWidget *widget)
{
- GtkSizeGroupPriv *priv;
+ GtkSizeGroupPrivate *priv;
GSList *groups;
g_return_if_fail (GTK_IS_SIZE_GROUP (size_group));
gtk_size_group_remove_widget (GtkSizeGroup *size_group,
GtkWidget *widget)
{
- GtkSizeGroupPriv *priv;
+ GtkSizeGroupPrivate *priv;
GSList *groups;
g_return_if_fail (GTK_IS_SIZE_GROUP (size_group));
else
{
GtkSizeGroup *group = groups->data;
- GtkSizeGroupPriv *priv = group->priv;
+ GtkSizeGroupPrivate *priv = group->priv;
if (mode == GTK_SIZE_GROUP_HORIZONTAL && priv->have_width)
result = priv->requisition.width;
while (tmp_list)
{
GtkSizeGroup *tmp_group = tmp_list->data;
- GtkSizeGroupPriv *tmp_priv = tmp_group->priv;
+ GtkSizeGroupPrivate *tmp_priv = tmp_group->priv;
if (mode == GTK_SIZE_GROUP_HORIZONTAL)
{
#define GTK_SIZE_GROUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SIZE_GROUP, GtkSizeGroupClass))
-typedef struct _GtkSizeGroup GtkSizeGroup;
-typedef struct _GtkSizeGroupPriv GtkSizeGroupPriv;
-typedef struct _GtkSizeGroupClass GtkSizeGroupClass;
+typedef struct _GtkSizeGroup GtkSizeGroup;
+typedef struct _GtkSizeGroupPrivate GtkSizeGroupPrivate;
+typedef struct _GtkSizeGroupClass GtkSizeGroupClass;
struct _GtkSizeGroup
{
GObject parent_instance;
/* <private> */
- GtkSizeGroupPriv *priv;
+ GtkSizeGroupPrivate *priv;
};
struct _GtkSizeGroupClass
#define MIN_ARROW_WIDTH 6
-struct _GtkSpinButtonPriv
+struct _GtkSpinButtonPrivate
{
GtkSpinButtonUpdatePolicy update_policy;
GtkAdjustment *adjustment;
add_spin_binding (binding_set, GDK_Page_Up, GDK_CONTROL_MASK, GTK_SCROLL_END);
add_spin_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK, GTK_SCROLL_START);
- g_type_class_add_private (class, sizeof (GtkSpinButtonPriv));
+ g_type_class_add_private (class, sizeof (GtkSpinButtonPrivate));
}
static void
GParamSpec *pspec)
{
GtkSpinButton *spin_button = GTK_SPIN_BUTTON (object);
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkSpinButton *spin_button = GTK_SPIN_BUTTON (object);
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
switch (prop_id)
{
static void
gtk_spin_button_init (GtkSpinButton *spin_button)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
spin_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (spin_button,
GTK_TYPE_SPIN_BUTTON,
- GtkSpinButtonPriv);
+ GtkSpinButtonPrivate);
priv = spin_button->priv;
priv->adjustment = NULL;
gtk_spin_button_map (GtkWidget *widget)
{
GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
if (gtk_widget_get_realized (widget) && !gtk_widget_get_mapped (widget))
{
gtk_spin_button_unmap (GtkWidget *widget)
{
GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
if (gtk_widget_get_mapped (widget))
{
gtk_spin_button_realize (GtkWidget *widget)
{
GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
GdkWindowAttr attributes;
gint attributes_mask;
gboolean return_val;
gtk_spin_button_unrealize (GtkWidget *widget)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->unrealize (widget);
GtkRequisition *requisition)
{
GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
GtkEntry *entry = GTK_ENTRY (widget);
gint arrow_size;
GtkAllocation *allocation)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
GtkAllocation panel_allocation;
gint arrow_size;
gint panel_width;
GdkEventExpose *event)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
if (gtk_widget_is_drawable (widget))
{
spin_button_at_limit (GtkSpinButton *spin_button,
GtkArrowType arrow)
{
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
GtkArrowType effective_arrow;
if (priv->wrap)
GdkRectangle *area,
GtkArrowType arrow_type)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
GtkStateType state_type;
GtkShadowType shadow_type;
GtkWidget *widget;
GdkEventCrossing *event)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
if (event->window == priv->panel)
{
GdkEventCrossing *event)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
priv->in_child = NO_ARROW;
gtk_widget_queue_draw (GTK_WIDGET (spin));
GtkStyle *previous_style)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
if (previous_style && gtk_widget_get_realized (widget))
gtk_style_set_background (widget->style, priv->panel, GTK_STATE_NORMAL);
GdkEventScroll *event)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
if (event->direction == GDK_SCROLL_UP)
{
static void
gtk_spin_button_stop_spinning (GtkSpinButton *spin)
{
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
if (priv->timer)
{
GtkArrowType click_child,
gdouble step)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (click_child == GTK_ARROW_UP || click_child == GTK_ARROW_DOWN);
GdkEventButton *event)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
if (!priv->button)
{
GdkEventButton *event)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
gint arrow_size;
arrow_size = spin_button_get_arrow_size (spin);
GdkEventMotion *event)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
if (priv->button)
return FALSE;
static gint
gtk_spin_button_timer (GtkSpinButton *spin_button)
{
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
gboolean retval = FALSE;
if (priv->timer)
gtk_spin_button_real_change_value (GtkSpinButton *spin,
GtkScrollType scroll)
{
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
gdouble old_value;
/* When the key binding is activated, there may be an outstanding
GdkEventKey *event)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
/* We only get a release at the end of a key repeat run, so reset the timer_step */
priv->timer_step = priv->adjustment->step_increment;
gtk_spin_button_snap (GtkSpinButton *spin_button,
gdouble val)
{
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
gdouble inc;
gdouble tmp;
{
GtkEntry *entry = GTK_ENTRY (editable);
GtkSpinButton *spin = GTK_SPIN_BUTTON (editable);
- GtkSpinButtonPriv *priv = spin->priv;
+ GtkSpinButtonPrivate *priv = spin->priv;
GtkEditableClass *parent_editable_iface = g_type_interface_peek (gtk_spin_button_parent_class, GTK_TYPE_EDITABLE);
if (priv->numeric)
gtk_spin_button_real_spin (GtkSpinButton *spin_button,
gdouble increment)
{
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
GtkAdjustment *adj;
gdouble new_value = 0.0;
gboolean wrapped = FALSE;
static gint
gtk_spin_button_default_output (GtkSpinButton *spin_button)
{
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
gchar *buf = g_strdup_printf ("%0.*f", priv->digits, priv->adjustment->value);
gdouble climb_rate,
guint digits)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
adjustment_changed_cb (GtkAdjustment *adjustment, gpointer data)
{
GtkSpinButton *spin_button = GTK_SPIN_BUTTON (data);
- GtkSpinButtonPriv *priv = spin_button->priv;
+ GtkSpinButtonPrivate *priv = spin_button->priv;
priv->timer_step = priv->adjustment->step_increment;
gtk_widget_queue_resize (GTK_WIDGET (spin_button));
gtk_spin_button_set_adjustment (GtkSpinButton *spin_button,
GtkAdjustment *adjustment)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gtk_spin_button_set_digits (GtkSpinButton *spin_button,
guint digits)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gdouble step,
gdouble page)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gdouble *step,
gdouble *page)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gdouble min,
gdouble max)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
gdouble value;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gdouble *min,
gdouble *max)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gint
gtk_spin_button_get_value_as_int (GtkSpinButton *spin_button)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
gdouble val;
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (spin_button), 0);
gtk_spin_button_set_value (GtkSpinButton *spin_button,
gdouble value)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gtk_spin_button_set_update_policy (GtkSpinButton *spin_button,
GtkSpinButtonUpdatePolicy policy)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gtk_spin_button_set_numeric (GtkSpinButton *spin_button,
gboolean numeric)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gtk_spin_button_set_wrap (GtkSpinButton *spin_button,
gboolean wrap)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gtk_spin_button_set_snap_to_ticks (GtkSpinButton *spin_button,
gboolean snap_to_ticks)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
guint new_val;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
GtkSpinType direction,
gdouble increment)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
GtkAdjustment *adj;
gdouble diff;
void
gtk_spin_button_update (GtkSpinButton *spin_button)
{
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
gdouble val;
gint error = 0;
gint return_val;
} GtkSpinType;
-typedef struct _GtkSpinButton GtkSpinButton;
-typedef struct _GtkSpinButtonPriv GtkSpinButtonPriv;
-typedef struct _GtkSpinButtonClass GtkSpinButtonClass;
+typedef struct _GtkSpinButton GtkSpinButton;
+typedef struct _GtkSpinButtonPrivate GtkSpinButtonPrivate;
+typedef struct _GtkSpinButtonClass GtkSpinButtonClass;
struct _GtkSpinButton
GtkEntry entry;
/* <private> */
- GtkSpinButtonPriv *priv;
+ GtkSpinButtonPrivate *priv;
};
struct _GtkSpinButtonClass
*/
typedef struct _GtkStatusbarMsg GtkStatusbarMsg;
-struct _GtkStatusbarPriv
+struct _GtkStatusbarPrivate
{
GtkWidget *frame;
GtkWidget *label;
GTK_SHADOW_IN,
GTK_PARAM_READABLE));
- g_type_class_add_private (class, sizeof (GtkStatusbarPriv));
+ g_type_class_add_private (class, sizeof (GtkStatusbarPrivate));
}
static void
gtk_statusbar_init (GtkStatusbar *statusbar)
{
- GtkStatusbarPriv *priv;
+ GtkStatusbarPrivate *priv;
GtkBox *box = GTK_BOX (statusbar);
GtkWidget *message_area;
GtkShadowType shadow_type;
statusbar->priv = G_TYPE_INSTANCE_GET_PRIVATE (statusbar,
GTK_TYPE_STATUSBAR,
- GtkStatusbarPriv);
+ GtkStatusbarPrivate);
priv = statusbar->priv;
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (box), TRUE);
const gchar *childname)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (buildable);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
if (strcmp (childname, "message_area") == 0)
return G_OBJECT (gtk_bin_get_child (GTK_BIN (priv->frame)));
guint context_id,
const gchar *text)
{
- GtkStatusbarPriv *priv;
+ GtkStatusbarPrivate *priv;
g_return_if_fail (GTK_IS_STATUSBAR (statusbar));
gtk_statusbar_get_context_id (GtkStatusbar *statusbar,
const gchar *context_description)
{
- GtkStatusbarPriv *priv;
+ GtkStatusbarPrivate *priv;
gchar *string;
guint id;
guint context_id,
const gchar *text)
{
- GtkStatusbarPriv *priv;
+ GtkStatusbarPrivate *priv;
GtkStatusbarMsg *msg;
g_return_val_if_fail (GTK_IS_STATUSBAR (statusbar), 0);
gtk_statusbar_pop (GtkStatusbar *statusbar,
guint context_id)
{
- GtkStatusbarPriv *priv;
+ GtkStatusbarPrivate *priv;
GtkStatusbarMsg *msg;
g_return_if_fail (GTK_IS_STATUSBAR (statusbar));
guint context_id,
guint message_id)
{
- GtkStatusbarPriv *priv;
+ GtkStatusbarPrivate *priv;
GtkStatusbarMsg *msg;
g_return_if_fail (GTK_IS_STATUSBAR (statusbar));
gtk_statusbar_remove_all (GtkStatusbar *statusbar,
guint context_id)
{
- GtkStatusbarPriv *priv;
+ GtkStatusbarPrivate *priv;
GtkStatusbarMsg *msg;
GSList *prev, *list;
gtk_statusbar_set_has_resize_grip (GtkStatusbar *statusbar,
gboolean setting)
{
- GtkStatusbarPriv *priv;
+ GtkStatusbarPrivate *priv;
g_return_if_fail (GTK_IS_STATUSBAR (statusbar));
GtkWidget*
gtk_statusbar_get_message_area (GtkStatusbar *statusbar)
{
- GtkStatusbarPriv *priv;
+ GtkStatusbarPrivate *priv;
g_return_val_if_fail (GTK_IS_STATUSBAR (statusbar), NULL);
gtk_statusbar_destroy (GtkObject *object)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (object);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
GSList *list;
for (list = priv->messages; list; list = list->next)
GParamSpec *pspec)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (object);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
switch (prop_id)
{
static void
set_grip_cursor (GtkStatusbar *statusbar)
{
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
if (priv->has_resize_grip && priv->grip_window != NULL)
{
gtk_statusbar_create_window (GtkStatusbar *statusbar)
{
GtkWidget *widget;
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
GdkWindowAttr attributes;
gint attributes_mask;
GdkRectangle rect;
static void
gtk_statusbar_destroy_window (GtkStatusbar *statusbar)
{
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
gdk_window_set_user_data (priv->grip_window, NULL);
gdk_window_destroy (priv->grip_window);
gtk_statusbar_realize (GtkWidget *widget)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
GTK_WIDGET_CLASS (gtk_statusbar_parent_class)->realize (widget);
gtk_statusbar_unrealize (GtkWidget *widget)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
if (priv->grip_window)
gtk_statusbar_destroy_window (statusbar);
gtk_statusbar_map (GtkWidget *widget)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
GTK_WIDGET_CLASS (gtk_statusbar_parent_class)->map (widget);
gtk_statusbar_unmap (GtkWidget *widget)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
if (priv->grip_window)
gdk_window_hide (priv->grip_window);
GdkEventButton *event)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
GtkWidget *ancestor;
GdkWindowEdge edge;
GdkEventExpose *event)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
GtkStyle *style;
GdkRectangle rect;
GtkRequisition *requisition)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
GtkShadowType shadow_type;
gtk_widget_style_get (GTK_WIDGET (statusbar), "shadow-type", &shadow_type, NULL);
static gboolean
has_extra_children (GtkStatusbar *statusbar)
{
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
GtkPackType child_pack_type, frame_pack_type;
GtkWidget *child, *frame;
GList *l, *children;
GtkAllocation *allocation)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
gboolean extra_children = FALSE;
GdkRectangle rect;
gpointer data)
{
GtkStatusbar *statusbar = GTK_STATUSBAR (data);
- GtkStatusbarPriv *priv = statusbar->priv;
+ GtkStatusbarPrivate *priv = statusbar->priv;
if (statusbar &&
priv->has_resize_grip && priv->grip_window)
#define GTK_STATUSBAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STATUSBAR, GtkStatusbarClass))
-typedef struct _GtkStatusbar GtkStatusbar;
-typedef struct _GtkStatusbarPriv GtkStatusbarPriv;
-typedef struct _GtkStatusbarClass GtkStatusbarClass;
+typedef struct _GtkStatusbar GtkStatusbar;
+typedef struct _GtkStatusbarPrivate GtkStatusbarPrivate;
+typedef struct _GtkStatusbarClass GtkStatusbarClass;
struct _GtkStatusbar
{
GtkHBox parent_widget;
/* <private> */
- GtkStatusbarPriv *priv;
+ GtkStatusbarPrivate *priv;
};
struct _GtkStatusbarClass
-struct _GtkTablePriv
+struct _GtkTablePrivate
{
GtkTableRowCol *cols;
GtkTableRowCol *rows;
0, 65535, 0,
GTK_PARAM_READWRITE));
- g_type_class_add_private (class, sizeof (GtkTablePriv));
+ g_type_class_add_private (class, sizeof (GtkTablePrivate));
}
static GType
GParamSpec *pspec)
{
GtkTable *table = GTK_TABLE (object);
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkTable *table = GTK_TABLE (object);
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkTable *table = GTK_TABLE (container);
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkTableChild *table_child;
GList *list;
GParamSpec *pspec)
{
GtkTable *table = GTK_TABLE (container);
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkTableChild *table_child;
GList *list;
static void
gtk_table_init (GtkTable *table)
{
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
table->priv = G_TYPE_INSTANCE_GET_PRIVATE (table,
GTK_TYPE_TABLE,
- GtkTablePriv);
+ GtkTablePrivate);
priv = table->priv;
gtk_widget_set_has_window (GTK_WIDGET (table), FALSE);
gboolean homogeneous)
{
GtkTable *table;
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
if (rows == 0)
rows = 1;
guint n_rows,
guint n_cols)
{
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
g_return_if_fail (GTK_IS_TABLE (table));
g_return_if_fail (n_rows > 0 && n_rows <= 65535);
guint xpadding,
guint ypadding)
{
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkTableChild *table_child;
g_return_if_fail (GTK_IS_TABLE (table));
guint row,
guint spacing)
{
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
g_return_if_fail (GTK_IS_TABLE (table));
gtk_table_get_row_spacing (GtkTable *table,
guint row)
{
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
g_return_val_if_fail (GTK_IS_TABLE (table), 0);
guint column,
guint spacing)
{
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
g_return_if_fail (GTK_IS_TABLE (table));
gtk_table_get_col_spacing (GtkTable *table,
guint column)
{
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
g_return_val_if_fail (GTK_IS_TABLE (table), 0);
gtk_table_set_row_spacings (GtkTable *table,
guint spacing)
{
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
guint row;
g_return_if_fail (GTK_IS_TABLE (table));
gtk_table_set_col_spacings (GtkTable *table,
guint spacing)
{
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
guint col;
g_return_if_fail (GTK_IS_TABLE (table));
gtk_table_set_homogeneous (GtkTable *table,
gboolean homogeneous)
{
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
g_return_if_fail (GTK_IS_TABLE (table));
guint *rows,
guint *columns)
{
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
g_return_if_fail (GTK_IS_TABLE (table));
gtk_table_finalize (GObject *object)
{
GtkTable *table = GTK_TABLE (object);
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
g_free (priv->rows);
g_free (priv->cols);
GtkRequisition *requisition)
{
GtkTable *table = GTK_TABLE (widget);
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
gint row, col;
guint border_width;
GtkWidget *widget)
{
GtkTable *table = GTK_TABLE (container);
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkTableChild *child;
GtkWidget *widget_container = GTK_WIDGET (container);
GList *children;
gpointer callback_data)
{
GtkTable *table = GTK_TABLE (container);
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkTableChild *child;
GList *children;
static void
gtk_table_size_request_init (GtkTable *table)
{
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkTableChild *child;
GList *children;
gint row, col;
static void
gtk_table_size_request_pass1 (GtkTable *table)
{
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkTableChild *child;
GList *children;
gint width;
static void
gtk_table_size_request_pass2 (GtkTable *table)
{
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
gint max_width;
gint max_height;
gint row, col;
static void
gtk_table_size_request_pass3 (GtkTable *table)
{
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkTableChild *child;
GList *children;
gint width, height;
static void
gtk_table_size_allocate_init (GtkTable *table)
{
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkTableChild *child;
GList *children;
gint row, col;
static void
gtk_table_size_allocate_pass1 (GtkTable *table)
{
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkAllocation allocation;
gint real_width;
gint real_height;
static void
gtk_table_size_allocate_pass2 (GtkTable *table)
{
- GtkTablePriv *priv = table->priv;
+ GtkTablePrivate *priv = table->priv;
GtkTableChild *child;
GList *children;
gint max_width;
#define GTK_TABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TABLE, GtkTableClass))
-typedef struct _GtkTable GtkTable;
-typedef struct _GtkTablePriv GtkTablePriv;
-typedef struct _GtkTableClass GtkTableClass;
-typedef struct _GtkTableChild GtkTableChild;
-typedef struct _GtkTableRowCol GtkTableRowCol;
+typedef struct _GtkTable GtkTable;
+typedef struct _GtkTablePrivate GtkTablePrivate;
+typedef struct _GtkTableClass GtkTableClass;
+typedef struct _GtkTableChild GtkTableChild;
+typedef struct _GtkTableRowCol GtkTableRowCol;
struct _GtkTable
{
GtkContainer container;
/* <private> */
- GtkTablePriv *priv;
+ GtkTablePrivate *priv;
};
struct _GtkTableClass
#define TEAR_LENGTH 5
#define BORDER_SPACING 3
-struct _GtkTearoffMenuItemPriv
+struct _GtkTearoffMenuItemPrivate
{
guint torn_off : 1;
};
menu_item_class->activate = gtk_tearoff_menu_item_activate;
- g_type_class_add_private (klass, sizeof (GtkTearoffMenuItemPriv));
+ g_type_class_add_private (klass, sizeof (GtkTearoffMenuItemPrivate));
}
static void
gtk_tearoff_menu_item_init (GtkTearoffMenuItem *tearoff_menu_item)
{
- GtkTearoffMenuItemPriv *priv;
+ GtkTearoffMenuItemPrivate *priv;
tearoff_menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (tearoff_menu_item,
GTK_TYPE_TEAROFF_MENU_ITEM,
- GtkTearoffMenuItemPriv);
+ GtkTearoffMenuItemPrivate);
priv = tearoff_menu_item->priv;
priv->torn_off = FALSE;
gpointer data)
{
GtkTearoffMenuItem *tearoff_menu_item = GTK_TEAROFF_MENU_ITEM (data);
- GtkTearoffMenuItemPriv *priv = tearoff_menu_item->priv;
+ GtkTearoffMenuItemPrivate *priv = tearoff_menu_item->priv;
priv->torn_off = gtk_menu_get_tearoff_state (menu);
}
GtkWidget *previous)
{
GtkTearoffMenuItem *tearoff_menu_item = GTK_TEAROFF_MENU_ITEM (widget);
- GtkTearoffMenuItemPriv *priv = tearoff_menu_item->priv;
+ GtkTearoffMenuItemPrivate *priv = tearoff_menu_item->priv;
GtkMenu *menu;
GtkWidget *parent;
#define GTK_TEAROFF_MENU_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEAROFF_MENU_ITEM, GtkTearoffMenuItemClass))
-typedef struct _GtkTearoffMenuItem GtkTearoffMenuItem;
-typedef struct _GtkTearoffMenuItemPriv GtkTearoffMenuItemPriv;
-typedef struct _GtkTearoffMenuItemClass GtkTearoffMenuItemClass;
+typedef struct _GtkTearoffMenuItem GtkTearoffMenuItem;
+typedef struct _GtkTearoffMenuItemPrivate GtkTearoffMenuItemPrivate;
+typedef struct _GtkTearoffMenuItemClass GtkTearoffMenuItemClass;
struct _GtkTearoffMenuItem
{
GtkMenuItem menu_item;
/* <private> */
- GtkTearoffMenuItemPriv *priv;
+ GtkTearoffMenuItemPrivate *priv;
};
struct _GtkTearoffMenuItemClass
#include <stdlib.h>
-struct _GtkTextTagTablePriv
+struct _GtkTextTagTablePrivate
{
GHashTable *hash;
GSList *anonymous;
1,
GTK_TYPE_TEXT_TAG);
- g_type_class_add_private (klass, sizeof (GtkTextTagTablePriv));
+ g_type_class_add_private (klass, sizeof (GtkTextTagTablePrivate));
}
static void
gtk_text_tag_table_init (GtkTextTagTable *table)
{
- GtkTextTagTablePriv *priv;
+ GtkTextTagTablePrivate *priv;
table->priv = G_TYPE_INSTANCE_GET_PRIVATE (table,
GTK_TYPE_TEXT_TAG_TABLE,
- GtkTextTagTablePriv);
+ GtkTextTagTablePrivate);
priv = table->priv;
priv->hash = g_hash_table_new (g_str_hash, g_str_equal);
foreach_unref (GtkTextTag *tag, gpointer data)
{
GtkTextTagTable *table = GTK_TEXT_TAG_TABLE (tag->table);
- GtkTextTagTablePriv *priv = table->priv;
+ GtkTextTagTablePrivate *priv = table->priv;
GSList *tmp;
/* We don't want to emit the remove signal here; so we just unparent
gtk_text_tag_table_finalize (GObject *object)
{
GtkTextTagTable *table = GTK_TEXT_TAG_TABLE (object);
- GtkTextTagTablePriv *priv = table->priv;
+ GtkTextTagTablePrivate *priv = table->priv;
gtk_text_tag_table_foreach (table, foreach_unref, NULL);
gtk_text_tag_table_add (GtkTextTagTable *table,
GtkTextTag *tag)
{
- GtkTextTagTablePriv *priv;
+ GtkTextTagTablePrivate *priv;
guint size;
g_return_if_fail (GTK_IS_TEXT_TAG_TABLE (table));
gtk_text_tag_table_lookup (GtkTextTagTable *table,
const gchar *name)
{
- GtkTextTagTablePriv *priv;
+ GtkTextTagTablePrivate *priv;
g_return_val_if_fail (GTK_IS_TEXT_TAG_TABLE (table), NULL);
g_return_val_if_fail (name != NULL, NULL);
gtk_text_tag_table_remove (GtkTextTagTable *table,
GtkTextTag *tag)
{
- GtkTextTagTablePriv *priv;
+ GtkTextTagTablePrivate *priv;
GSList *tmp;
g_return_if_fail (GTK_IS_TEXT_TAG_TABLE (table));
GtkTextTagTableForeach func,
gpointer data)
{
- GtkTextTagTablePriv *priv;
+ GtkTextTagTablePrivate *priv;
struct ForeachData d;
g_return_if_fail (GTK_IS_TEXT_TAG_TABLE (table));
gint
gtk_text_tag_table_get_size (GtkTextTagTable *table)
{
- GtkTextTagTablePriv *priv;
+ GtkTextTagTablePrivate *priv;
g_return_val_if_fail (GTK_IS_TEXT_TAG_TABLE (table), 0);
_gtk_text_tag_table_add_buffer (GtkTextTagTable *table,
gpointer buffer)
{
- GtkTextTagTablePriv *priv = table->priv;
+ GtkTextTagTablePrivate *priv = table->priv;
priv->buffers = g_slist_prepend (priv->buffers, buffer);
}
_gtk_text_tag_table_remove_buffer (GtkTextTagTable *table,
gpointer buffer)
{
- GtkTextTagTablePriv *priv = table->priv;
+ GtkTextTagTablePrivate *priv = table->priv;
gtk_text_tag_table_foreach (table, foreach_remove_tag, buffer);
#define GTK_IS_TEXT_TAG_TABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_TAG_TABLE))
#define GTK_TEXT_TAG_TABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_TAG_TABLE, GtkTextTagTableClass))
-typedef struct _GtkTextTagTablePriv GtkTextTagTablePriv;
-typedef struct _GtkTextTagTableClass GtkTextTagTableClass;
+typedef struct _GtkTextTagTablePrivate GtkTextTagTablePrivate;
+typedef struct _GtkTextTagTableClass GtkTextTagTableClass;
struct _GtkTextTagTable
{
GObject parent_instance;
- GtkTextTagTablePriv *priv;
+ GtkTextTagTablePrivate *priv;
};
struct _GtkTextTagTableClass
#define ACCEL_THRESHOLD 0.18 /* After how much time in seconds will items start speeding up */
-struct _GtkToolbarPriv
+struct _GtkToolbarPrivate
{
GtkIconSize icon_size;
GtkMenu *menu;
add_ctrl_tab_bindings (binding_set, 0, GTK_DIR_TAB_FORWARD);
add_ctrl_tab_bindings (binding_set, GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
- g_type_class_add_private (gobject_class, sizeof (GtkToolbarPriv));
+ g_type_class_add_private (gobject_class, sizeof (GtkToolbarPrivate));
}
static void
static void
gtk_toolbar_init (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
toolbar->priv = G_TYPE_INSTANCE_GET_PRIVATE (toolbar,
GTK_TYPE_TOOLBAR,
- GtkToolbarPriv);
+ GtkToolbarPrivate);
priv = toolbar->priv;
gtk_widget_set_can_focus (GTK_WIDGET (toolbar), FALSE);
GParamSpec *pspec)
{
GtkToolbar *toolbar = GTK_TOOLBAR (object);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
switch (prop_id)
{
GParamSpec *pspec)
{
GtkToolbar *toolbar = GTK_TOOLBAR (object);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
switch (prop_id)
{
gtk_toolbar_map (GtkWidget *widget)
{
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GTK_WIDGET_CLASS (gtk_toolbar_parent_class)->map (widget);
gtk_toolbar_unmap (GtkWidget *widget)
{
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
if (priv->event_window)
gdk_window_hide (priv->event_window);
{
GtkAllocation allocation;
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GdkWindow *window;
GdkWindowAttr attributes;
gint attributes_mask;
gtk_toolbar_unrealize (GtkWidget *widget)
{
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
if (priv->event_window)
{
{
GtkAllocation allocation;
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
guint border_width;
GtkRequisition *requisition)
{
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
gint max_child_height;
gint max_child_width;
gint to,
gdouble elapsed)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
gint n_pixels;
if (!priv->animation)
const GtkAllocation *goal,
GtkAllocation *intermediate)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
gdouble elapsed = g_timer_elapsed (priv->timer, NULL);
intermediate->x = position (toolbar, start->x, goal->x, elapsed);
get_item_size (GtkToolbar *toolbar,
ToolbarContent *content)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GtkRequisition requisition;
toolbar_content_size_request (content, toolbar, &requisition);
slide_idle_handler (gpointer data)
{
GtkToolbar *toolbar = GTK_TOOLBAR (data);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
if (priv->need_sync)
{
GtkAllocation allocation;
GtkWidget *widget = GTK_WIDGET (toolbar);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GtkStyle *style;
GList *list;
gint cur_x;
static void
gtk_toolbar_stop_sliding (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
if (priv->is_sliding)
{
menu_deactivated (GtkWidget *menu,
GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->arrow_button), FALSE);
}
GtkMenu *menu)
{
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
priv->menu = NULL;
}
static void
rebuild_menu (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list, *children;
if (!priv->menu)
{
GtkAllocation widget_allocation;
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GtkAllocation *allocations;
ItemState *new_states;
GtkAllocation arrow_allocation;
static void
gtk_toolbar_update_button_relief (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GtkReliefStyle relief;
relief = get_button_relief (toolbar);
GtkStyle *prev_style)
{
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
priv->max_homogeneous_pixels = -1;
gtk_toolbar_list_children_in_focus_order (GtkToolbar *toolbar,
GtkDirectionType dir)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *result = NULL;
GList *list;
gboolean rtl;
static void
style_change_notify (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
if (!priv->style_set)
{
static void
icon_size_change_notify (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
if (!priv->icon_size_set)
{
static void
animation_change_notify (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GtkSettings *settings = toolbar_get_settings (toolbar);
gboolean animation;
GdkScreen *previous_screen)
{
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GtkSettings *old_settings = toolbar_get_settings (toolbar);
GtkSettings *settings;
gint x,
gint y)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *interesting_content;
GList *list;
GtkOrientation orientation;
static void
reset_all_placeholders (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
for (list = priv->content; list != NULL; list = list->next)
physical_to_logical (GtkToolbar *toolbar,
gint physical)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
int logical;
logical_to_physical (GtkToolbar *toolbar,
gint logical)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
gint physical;
gint index_)
{
ToolbarContent *content;
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
gint n_items;
GtkRequisition requisition;
GtkRequisition old_requisition;
gtk_toolbar_show_all (GtkWidget *widget)
{
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
for (list = priv->content; list != NULL; list = list->next)
gtk_toolbar_hide_all (GtkWidget *widget)
{
GtkToolbar *toolbar = GTK_TOOLBAR (widget);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
for (list = priv->content; list != NULL; list = list->next)
GtkWidget *widget)
{
GtkToolbar *toolbar = GTK_TOOLBAR (container);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
ToolbarContent *content_to_remove;
GList *list;
gpointer callback_data)
{
GtkToolbar *toolbar = GTK_TOOLBAR (container);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
g_return_if_fail (callback != NULL);
static void
gtk_toolbar_reconfigured (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
list = priv->content;
gtk_toolbar_orientation_changed (GtkToolbar *toolbar,
GtkOrientation orientation)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
if (priv->orientation != orientation)
{
gtk_toolbar_real_style_changed (GtkToolbar *toolbar,
GtkToolbarStyle style)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
if (priv->style != style)
{
{
GtkAllocation allocation;
GtkToolbar *toolbar = GTK_TOOLBAR (user_data);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GtkRequisition req;
GtkRequisition menu_req;
GdkRectangle monitor;
show_menu (GtkToolbar *toolbar,
GdkEventButton *event)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
rebuild_menu (toolbar);
gtk_toolbar_arrow_button_clicked (GtkWidget *button,
GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->arrow_button)) &&
(!priv->menu || !gtk_widget_get_visible (GTK_WIDGET (priv->menu))))
gtk_toolbar_get_item_index (GtkToolbar *toolbar,
GtkToolItem *item)
{
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
GList *list;
int n;
gtk_toolbar_set_style (GtkToolbar *toolbar,
GtkToolbarStyle style)
{
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
void
gtk_toolbar_unset_style (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
GtkToolbarStyle style;
g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
gint
gtk_toolbar_get_n_items (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
g_return_val_if_fail (GTK_IS_TOOLBAR (toolbar), -1);
gtk_toolbar_get_nth_item (GtkToolbar *toolbar,
gint n)
{
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
ToolbarContent *content;
gint n_items;
gtk_toolbar_set_show_arrow (GtkToolbar *toolbar,
gboolean show_arrow)
{
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
{
GList *list;
GtkToolbar *toolbar = GTK_TOOLBAR (object);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
if (priv->arrow_button)
gtk_widget_unparent (priv->arrow_button);
gtk_toolbar_set_icon_size (GtkToolbar *toolbar,
GtkIconSize icon_size)
{
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
g_return_if_fail (icon_size != GTK_ICON_SIZE_INVALID);
void
gtk_toolbar_unset_icon_size (GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
GtkIconSize size;
g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
gboolean is_placeholder,
gint pos)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
ToolbarContent *content;
content = g_slice_new0 (ToolbarContent);
toolbar_content_remove (ToolbarContent *content,
GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
gtk_widget_unparent (GTK_WIDGET (content->item));
toolbar_content_visible (ToolbarContent *content,
GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GtkToolItem *item;
item = content->item;
toolbar_content_is_homogeneous (ToolbarContent *content,
GtkToolbar *toolbar)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GtkRequisition requisition;
gboolean result;
const GdkRectangle *area,
const GtkAllocation *allocation)
{
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GtkOrientation orientation;
GtkStateType state;
GtkStyle *style;
toolbar_get_icon_size (GtkToolShell *shell)
{
GtkToolbar *toolbar = GTK_TOOLBAR (shell);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
return priv->icon_size;
}
toolbar_get_orientation (GtkToolShell *shell)
{
GtkToolbar *toolbar = GTK_TOOLBAR (shell);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
return priv->orientation;
}
toolbar_get_style (GtkToolShell *shell)
{
GtkToolbar *toolbar = GTK_TOOLBAR (shell);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
return priv->style;
}
toolbar_rebuild_menu (GtkToolShell *shell)
{
GtkToolbar *toolbar = GTK_TOOLBAR (shell);
- GtkToolbarPriv *priv = toolbar->priv;
+ GtkToolbarPrivate *priv = toolbar->priv;
GList *list;
priv->need_rebuild = TRUE;
GTK_TOOLBAR_SPACE_LINE
} GtkToolbarSpaceStyle;
-typedef struct _GtkToolbar GtkToolbar;
-typedef struct _GtkToolbarPriv GtkToolbarPriv;
-typedef struct _GtkToolbarClass GtkToolbarClass;
+typedef struct _GtkToolbar GtkToolbar;
+typedef struct _GtkToolbarPrivate GtkToolbarPrivate;
+typedef struct _GtkToolbarClass GtkToolbarClass;
struct _GtkToolbar
{
GtkContainer container;
- GtkToolbarPriv *priv;
+ GtkToolbarPrivate *priv;
};
struct _GtkToolbarClass
* exactly this, so you can ignore the presence of the viewport.
*/
-struct _GtkViewportPriv
+struct _GtkViewportPrivate
{
GtkAdjustment *hadjustment;
GtkAdjustment *vadjustment;
GTK_TYPE_ADJUSTMENT,
GTK_TYPE_ADJUSTMENT);
- g_type_class_add_private (class, sizeof (GtkViewportPriv));
+ g_type_class_add_private (class, sizeof (GtkViewportPrivate));
}
static void
GParamSpec *pspec)
{
GtkViewport *viewport = GTK_VIEWPORT (object);
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
switch (prop_id)
{
static void
gtk_viewport_init (GtkViewport *viewport)
{
- GtkViewportPriv *priv;
+ GtkViewportPrivate *priv;
viewport->priv = G_TYPE_INSTANCE_GET_PRIVATE (viewport,
GTK_TYPE_VIEWPORT,
- GtkViewportPriv);
+ GtkViewportPrivate);
priv = viewport->priv;
gtk_widget_set_has_window (GTK_WIDGET (viewport), TRUE);
GtkAdjustment*
gtk_viewport_get_hadjustment (GtkViewport *viewport)
{
- GtkViewportPriv *priv;
+ GtkViewportPrivate *priv;
g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), NULL);
GtkAdjustment*
gtk_viewport_get_vadjustment (GtkViewport *viewport)
{
- GtkViewportPriv *priv;
+ GtkViewportPrivate *priv;
g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), NULL);
viewport_get_view_allocation (GtkViewport *viewport,
GtkAllocation *view_allocation)
{
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
GtkStyle *style;
GtkWidget *widget = GTK_WIDGET (viewport);
GtkAllocation allocation;
gtk_viewport_set_shadow_type (GtkViewport *viewport,
GtkShadowType type)
{
- GtkViewportPriv *priv;
+ GtkViewportPrivate *priv;
GtkAllocation allocation;
GtkWidget *widget;
gtk_viewport_realize (GtkWidget *widget)
{
GtkViewport *viewport = GTK_VIEWPORT (widget);
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
GtkBin *bin = GTK_BIN (widget);
GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
GtkAdjustment *vadjustment = gtk_viewport_get_vadjustment (viewport);
gtk_viewport_unrealize (GtkWidget *widget)
{
GtkViewport *viewport = GTK_VIEWPORT (widget);
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
gdk_window_set_user_data (priv->view_window, NULL);
gdk_window_destroy (priv->view_window);
if (gtk_widget_is_drawable (widget))
{
GtkViewport *viewport = GTK_VIEWPORT (widget);
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
gtk_paint_shadow (gtk_widget_get_style (widget),
gtk_widget_get_window (widget),
if (gtk_widget_is_drawable (widget))
{
viewport = GTK_VIEWPORT (widget);
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
if (event->window == gtk_widget_get_window (widget))
gtk_viewport_paint (widget, &event->area);
{
GtkBin *bin = GTK_BIN (container);
GtkViewport *viewport = GTK_VIEWPORT (bin);
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
g_return_if_fail (gtk_bin_get_child (bin) == NULL);
{
GtkAllocation widget_allocation;
GtkViewport *viewport = GTK_VIEWPORT (widget);
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
GtkBin *bin = GTK_BIN (widget);
guint border_width;
gboolean hadjustment_value_changed, vadjustment_value_changed;
gpointer data)
{
GtkViewport *viewport = GTK_VIEWPORT (data);
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
GtkBin *bin = GTK_BIN (data);
GtkWidget *child;
{
GtkStyle *style;
GtkViewport *viewport = GTK_VIEWPORT (widget);
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
style = gtk_widget_get_style (widget);
gtk_style_set_background (style, priv->bin_window, GTK_STATE_NORMAL);
gint *natural_size)
{
GtkViewport *viewport = GTK_VIEWPORT (widget);
- GtkViewportPriv *priv = viewport->priv;
+ GtkViewportPrivate *priv = viewport->priv;
GtkStyle *style;
GtkWidget *child;
gint child_min, child_nat;
#define GTK_VIEWPORT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VIEWPORT, GtkViewportClass))
-typedef struct _GtkViewport GtkViewport;
-typedef struct _GtkViewportPriv GtkViewportPriv;
-typedef struct _GtkViewportClass GtkViewportClass;
+typedef struct _GtkViewport GtkViewport;
+typedef struct _GtkViewportPrivate GtkViewportPrivate;
+typedef struct _GtkViewportClass GtkViewportClass;
struct _GtkViewport
{
GtkBin bin;
/* <private> */
- GtkViewportPriv *priv;
+ GtkViewportPrivate *priv;
};
struct _GtkViewportClass
projects / gtk4.git / commitdiff